From e398bbbc1227bc21f28be8be06a5abba50272a98 Mon Sep 17 00:00:00 2001 From: php-generics <264588703+php-generics@users.noreply.github.com> Date: Sat, 28 Feb 2026 09:29:56 +0100 Subject: [PATCH 01/10] Add generics support to PHP Implement reified generics with type parameter declarations on classes, interfaces, traits, and functions. Includes type constraint enforcement, variance checking, type inference, reflection API support, and comprehensive test suite. --- Zend/tests/generics/generic_class_basic.phpt | 19 + .../generic_class_constrained_param.phpt | 22 + .../generics/generic_class_inheritance.phpt | 24 + .../generic_class_multiple_params.phpt | 22 + .../generic_class_new_with_type_args.phpt | 19 + .../generic_class_type_enforcement.phpt | 18 + Zend/tests/generics/generic_clone.phpt | 29 + Zend/tests/generics/generic_closure.phpt | 72 + .../generic_constraint_enforcement.phpt | 23 + .../generic_contravariance_error.phpt | 11 + .../generic_contravariance_subtype.phpt | 34 + .../generics/generic_covariance_basic.phpt | 26 + .../generics/generic_covariance_error.phpt | 11 + .../generics/generic_covariance_subtype.phpt | 36 + .../generic_error_message_resolved.phpt | 17 + .../generics/generic_function_basic.phpt | 16 + ...eneric_inheritance_arg_count_mismatch.phpt | 13 + ...generic_inheritance_method_resolution.phpt | 30 + Zend/tests/generics/generic_instanceof.phpt | 36 + .../generic_interface_bad_override.phpt | 15 + .../generics/generic_interface_basic.phpt | 13 + .../generic_interface_implementation.phpt | 27 + Zend/tests/generics/generic_nested.phpt | 39 + .../generics/generic_promoted_property.phpt | 53 + Zend/tests/generics/generic_reflection.phpt | 108 + Zend/tests/generics/generic_trait_basic.phpt | 47 + .../generics/generic_trait_multi_param.phpt | 38 + .../generics/generic_trait_reflection.phpt | 60 + .../generic_type_inference_basic.phpt | 43 + .../generic_type_inference_multi_param.phpt | 41 + .../generic_type_inference_weak_mode.phpt | 36 + .../generics/generic_typed_property.phpt | 28 + .../generic_typed_property_direct.phpt | 27 + Zend/zend.h | 11 + Zend/zend_ast.c | 7 +- Zend/zend_ast.h | 9 +- Zend/zend_compile.c | 407 +- Zend/zend_compile.h | 6 + Zend/zend_execute.c | 146 +- Zend/zend_execute.h | 1 + Zend/zend_generics.c | 363 + Zend/zend_generics.h | 99 + Zend/zend_globals.h | 12 + Zend/zend_inheritance.c | 175 +- Zend/zend_language_parser.y | 136 +- Zend/zend_language_scanner.l | 158 +- Zend/zend_object_handlers.c | 2 +- Zend/zend_objects.c | 12 + Zend/zend_opcode.c | 63 + Zend/zend_types.h | 30 + Zend/zend_vm_def.h | 48 +- Zend/zend_vm_execute.h | 37837 +++++++++------- configure.ac | 1 + ext/reflection/php_reflection.c | 243 +- ext/reflection/php_reflection.h | 1 + ext/reflection/php_reflection.stub.php | 34 + ext/reflection/php_reflection_arginfo.h | 67 + ext/tokenizer/tokenizer_data.c | 1 + win32/build/config.w32 | 2 +- 59 files changed, 25328 insertions(+), 15596 deletions(-) create mode 100644 Zend/tests/generics/generic_class_basic.phpt create mode 100644 Zend/tests/generics/generic_class_constrained_param.phpt create mode 100644 Zend/tests/generics/generic_class_inheritance.phpt create mode 100644 Zend/tests/generics/generic_class_multiple_params.phpt create mode 100644 Zend/tests/generics/generic_class_new_with_type_args.phpt create mode 100644 Zend/tests/generics/generic_class_type_enforcement.phpt create mode 100644 Zend/tests/generics/generic_clone.phpt create mode 100644 Zend/tests/generics/generic_closure.phpt create mode 100644 Zend/tests/generics/generic_constraint_enforcement.phpt create mode 100644 Zend/tests/generics/generic_contravariance_error.phpt create mode 100644 Zend/tests/generics/generic_contravariance_subtype.phpt create mode 100644 Zend/tests/generics/generic_covariance_basic.phpt create mode 100644 Zend/tests/generics/generic_covariance_error.phpt create mode 100644 Zend/tests/generics/generic_covariance_subtype.phpt create mode 100644 Zend/tests/generics/generic_error_message_resolved.phpt create mode 100644 Zend/tests/generics/generic_function_basic.phpt create mode 100644 Zend/tests/generics/generic_inheritance_arg_count_mismatch.phpt create mode 100644 Zend/tests/generics/generic_inheritance_method_resolution.phpt create mode 100644 Zend/tests/generics/generic_instanceof.phpt create mode 100644 Zend/tests/generics/generic_interface_bad_override.phpt create mode 100644 Zend/tests/generics/generic_interface_basic.phpt create mode 100644 Zend/tests/generics/generic_interface_implementation.phpt create mode 100644 Zend/tests/generics/generic_nested.phpt create mode 100644 Zend/tests/generics/generic_promoted_property.phpt create mode 100644 Zend/tests/generics/generic_reflection.phpt create mode 100644 Zend/tests/generics/generic_trait_basic.phpt create mode 100644 Zend/tests/generics/generic_trait_multi_param.phpt create mode 100644 Zend/tests/generics/generic_trait_reflection.phpt create mode 100644 Zend/tests/generics/generic_type_inference_basic.phpt create mode 100644 Zend/tests/generics/generic_type_inference_multi_param.phpt create mode 100644 Zend/tests/generics/generic_type_inference_weak_mode.phpt create mode 100644 Zend/tests/generics/generic_typed_property.phpt create mode 100644 Zend/tests/generics/generic_typed_property_direct.phpt create mode 100644 Zend/zend_generics.c create mode 100644 Zend/zend_generics.h diff --git a/Zend/tests/generics/generic_class_basic.phpt b/Zend/tests/generics/generic_class_basic.phpt new file mode 100644 index 0000000000000..17e1de8ce1a15 --- /dev/null +++ b/Zend/tests/generics/generic_class_basic.phpt @@ -0,0 +1,19 @@ +--TEST-- +Generic class: basic declaration and instantiation +--FILE-- + { + private $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +$box = new Box(42); +echo $box->get() . "\n"; + +$box2 = new Box("hello"); +echo $box2->get() . "\n"; +?> +--EXPECT-- +42 +hello diff --git a/Zend/tests/generics/generic_class_constrained_param.phpt b/Zend/tests/generics/generic_class_constrained_param.phpt new file mode 100644 index 0000000000000..bd1e95e0d542a --- /dev/null +++ b/Zend/tests/generics/generic_class_constrained_param.phpt @@ -0,0 +1,22 @@ +--TEST-- +Generic class: constrained type parameter with upper bound +--FILE-- + { + private array $items = []; + public function add(T $item): void { + $this->items[] = $item; + } + public function count(): int { + return count($this->items); + } +} + +echo "TypedCollection declared\n"; + +$c = new TypedCollection(); +echo "Instantiated\n"; +?> +--EXPECT-- +TypedCollection declared +Instantiated diff --git a/Zend/tests/generics/generic_class_inheritance.phpt b/Zend/tests/generics/generic_class_inheritance.phpt new file mode 100644 index 0000000000000..8e030159290f7 --- /dev/null +++ b/Zend/tests/generics/generic_class_inheritance.phpt @@ -0,0 +1,24 @@ +--TEST-- +Generic class: inheritance with bound type arguments +--FILE-- + { + private $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +class IntBox extends Box {} + +$ib = new IntBox(99); +echo $ib->get() . "\n"; + +try { + $bad = new IntBox("not an int"); +} catch (TypeError $e) { + echo "TypeError caught\n"; +} +?> +--EXPECT-- +99 +TypeError caught diff --git a/Zend/tests/generics/generic_class_multiple_params.phpt b/Zend/tests/generics/generic_class_multiple_params.phpt new file mode 100644 index 0000000000000..6c35890286075 --- /dev/null +++ b/Zend/tests/generics/generic_class_multiple_params.phpt @@ -0,0 +1,22 @@ +--TEST-- +Generic class: multiple type parameters +--FILE-- + { + private $first; + private $second; + public function __construct(A $first, B $second) { + $this->first = $first; + $this->second = $second; + } + public function getFirst(): A { return $this->first; } + public function getSecond(): B { return $this->second; } +} + +$pair = new Pair("hello", 42); +echo $pair->getFirst() . "\n"; +echo $pair->getSecond() . "\n"; +?> +--EXPECT-- +hello +42 diff --git a/Zend/tests/generics/generic_class_new_with_type_args.phpt b/Zend/tests/generics/generic_class_new_with_type_args.phpt new file mode 100644 index 0000000000000..81790ffff5214 --- /dev/null +++ b/Zend/tests/generics/generic_class_new_with_type_args.phpt @@ -0,0 +1,19 @@ +--TEST-- +Generic class: new with explicit type arguments +--FILE-- + { + private $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +$intBox = new Box(42); +echo $intBox->get() . "\n"; + +$strBox = new Box("hello"); +echo $strBox->get() . "\n"; +?> +--EXPECT-- +42 +hello diff --git a/Zend/tests/generics/generic_class_type_enforcement.phpt b/Zend/tests/generics/generic_class_type_enforcement.phpt new file mode 100644 index 0000000000000..6a573eb2ad6a1 --- /dev/null +++ b/Zend/tests/generics/generic_class_type_enforcement.phpt @@ -0,0 +1,18 @@ +--TEST-- +Generic class: type enforcement on constructor parameter +--FILE-- + { + private $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +try { + $box = new Box("not an int"); +} catch (TypeError $e) { + echo "TypeError: " . $e->getMessage() . "\n"; +} +?> +--EXPECTF-- +TypeError: Box::__construct(): Argument #1 ($value) must be of type int, string given, called in %s on line %d diff --git a/Zend/tests/generics/generic_clone.phpt b/Zend/tests/generics/generic_clone.phpt new file mode 100644 index 0000000000000..2608906746d0d --- /dev/null +++ b/Zend/tests/generics/generic_clone.phpt @@ -0,0 +1,29 @@ +--TEST-- +Generic class: clone preserves generic type arguments +--FILE-- + { + public T $value; + public function __construct(T $value) { $this->value = $value; } +} + +$a = new Box(42); +$b = clone $a; + +echo $b->value . "\n"; + +// Clone should preserve generic args — assigning wrong type should fail +try { + $b->value = "hello"; +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +echo "OK\n"; +?> +--EXPECTF-- +42 +Cannot assign string to property Box::$value of type int +OK diff --git a/Zend/tests/generics/generic_closure.phpt b/Zend/tests/generics/generic_closure.phpt new file mode 100644 index 0000000000000..3b20b2fab63ad --- /dev/null +++ b/Zend/tests/generics/generic_closure.phpt @@ -0,0 +1,72 @@ +--TEST-- +Generic closures and arrow functions +--FILE-- +(T $value): T { + return $value; +}; + +echo $identity(42) . "\n"; // 42 +echo $identity("hello") . "\n"; // hello + +// Generic arrow function +$wrap = fn(T $x): array => [$x]; +var_dump($wrap(42)); // array(1) { [0]=> int(42) } +var_dump($wrap("hello")); // array(1) { [0]=> string(5) "hello" } + +// Generic closure with constraint +$count = function(T $item): int { + return count($item); +}; + +echo $count(new ArrayObject([1, 2, 3])) . "\n"; // 3 + +// Multiple type params +$pair = fn(A $a, B $b): array => [$a, $b]; +var_dump($pair(1, "two")); // array(2) { [0]=> int(1) [1]=> string(3) "two" } + +// Reflection on generic closures +$rf = new ReflectionFunction($identity); +var_dump($rf->isGeneric()); // true +$params = $rf->getGenericParameters(); +echo "identity generic params: " . count($params) . "\n"; +echo " T: " . $params[0]->getName() . "\n"; + +// Reflection on generic arrow function +$rf2 = new ReflectionFunction($wrap); +var_dump($rf2->isGeneric()); // true + +// Non-generic closure for comparison +$plain = function(int $x): int { return $x * 2; }; +$rf3 = new ReflectionFunction($plain); +var_dump($rf3->isGeneric()); // false + +echo "OK\n"; +?> +--EXPECT-- +42 +hello +array(1) { + [0]=> + int(42) +} +array(1) { + [0]=> + string(5) "hello" +} +3 +array(2) { + [0]=> + int(1) + [1]=> + string(3) "two" +} +bool(true) +identity generic params: 1 + T: T +bool(true) +bool(false) +OK diff --git a/Zend/tests/generics/generic_constraint_enforcement.phpt b/Zend/tests/generics/generic_constraint_enforcement.phpt new file mode 100644 index 0000000000000..cea7261060ef8 --- /dev/null +++ b/Zend/tests/generics/generic_constraint_enforcement.phpt @@ -0,0 +1,23 @@ +--TEST-- +Generic class: constraint enforcement at instantiation +--FILE-- + { + private array $items = []; + public function add(T $item): void { + $this->items[] = $item; + } +} + +// ArrayObject implements Countable — should work +$c = new TypedCollection(); +echo "ArrayObject accepted\n"; + +// string does NOT implement Countable — should fatal error +$c2 = new TypedCollection(); +echo "Should not reach here\n"; +?> +--EXPECTF-- +ArrayObject accepted + +Fatal error: Generic type argument #1 must implement Countable, string given in %s on line %d diff --git a/Zend/tests/generics/generic_contravariance_error.phpt b/Zend/tests/generics/generic_contravariance_error.phpt new file mode 100644 index 0000000000000..32855b13be882 --- /dev/null +++ b/Zend/tests/generics/generic_contravariance_error.phpt @@ -0,0 +1,11 @@ +--TEST-- +Generic class: contravariance (in) compile error when used in return position +--FILE-- + { + public function get(): T { return null; } +} +?> +--EXPECTF-- +Fatal error: Contravariant type parameter T of class BadConsumer cannot be used in return type of method BadConsumer::get() (only parameter types allowed) in %s on line %d diff --git a/Zend/tests/generics/generic_contravariance_subtype.phpt b/Zend/tests/generics/generic_contravariance_subtype.phpt new file mode 100644 index 0000000000000..d7d04f0ad8274 --- /dev/null +++ b/Zend/tests/generics/generic_contravariance_subtype.phpt @@ -0,0 +1,34 @@ +--TEST-- +Generic class: contravariant subtyping (Consumer assignable to Consumer) +--FILE-- +name = $name; } +} +class Dog extends Animal {} + +class Consumer { + private mixed $callback; + public function __construct(mixed $callback) { $this->callback = $callback; } + public function consume(T $item): void { + echo ($this->callback)($item) . "\n"; + } +} + +function feedDog(Consumer $consumer): void { + $consumer->consume(new Dog("Rex")); +} + +// Contravariant: Consumer should be assignable to Consumer +// because a consumer of Animals can consume any Dog (Dog is an Animal) +$animalConsumer = new Consumer(function(Animal $a) { return "Consumed: " . $a->name; }); +feedDog($animalConsumer); + +echo "OK\n"; +?> +--EXPECT-- +Consumed: Rex +OK diff --git a/Zend/tests/generics/generic_covariance_basic.phpt b/Zend/tests/generics/generic_covariance_basic.phpt new file mode 100644 index 0000000000000..1b1ac655c3eb6 --- /dev/null +++ b/Zend/tests/generics/generic_covariance_basic.phpt @@ -0,0 +1,26 @@ +--TEST-- +Generic class: covariance (out) annotation and compile-time validation +--FILE-- + { + private mixed $value; + public function __construct(mixed $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +$dogBox = new ReadOnlyBox(new Dog()); +$dog = $dogBox->get(); +echo get_class($dog) . "\n"; + +echo "OK\n"; +?> +--EXPECT-- +Dog +OK diff --git a/Zend/tests/generics/generic_covariance_error.phpt b/Zend/tests/generics/generic_covariance_error.phpt new file mode 100644 index 0000000000000..d7c0995284f14 --- /dev/null +++ b/Zend/tests/generics/generic_covariance_error.phpt @@ -0,0 +1,11 @@ +--TEST-- +Generic class: covariance (out) compile error when used in parameter position +--FILE-- + { + public function set(T $value): void {} +} +?> +--EXPECTF-- +Fatal error: Covariant type parameter T of class BadBox cannot be used in parameter $value of method BadBox::set() (only return types allowed) in %s on line %d diff --git a/Zend/tests/generics/generic_covariance_subtype.phpt b/Zend/tests/generics/generic_covariance_subtype.phpt new file mode 100644 index 0000000000000..c40e4cab4a06f --- /dev/null +++ b/Zend/tests/generics/generic_covariance_subtype.phpt @@ -0,0 +1,36 @@ +--TEST-- +Generic class: covariant subtyping (ReadOnlyBox assignable to ReadOnlyBox) +--FILE-- +name = $name; } +} +class Dog extends Animal {} +class Cat extends Animal {} + +class ReadOnlyBox { + private mixed $value; + public function __construct(mixed $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +function processAnimalBox(ReadOnlyBox $box): string { + return $box->get()->name; +} + +// Covariant: ReadOnlyBox should be assignable to ReadOnlyBox +$dogBox = new ReadOnlyBox(new Dog("Rex")); +echo processAnimalBox($dogBox) . "\n"; + +$catBox = new ReadOnlyBox(new Cat("Whiskers")); +echo processAnimalBox($catBox) . "\n"; + +echo "OK\n"; +?> +--EXPECT-- +Rex +Whiskers +OK diff --git a/Zend/tests/generics/generic_error_message_resolved.phpt b/Zend/tests/generics/generic_error_message_resolved.phpt new file mode 100644 index 0000000000000..9f8bc45fd2d91 --- /dev/null +++ b/Zend/tests/generics/generic_error_message_resolved.phpt @@ -0,0 +1,17 @@ +--TEST-- +Generic class: error messages show resolved type names +--FILE-- + { + public function __construct(T $value) {} +} + +// Should show "int" not "T" in error message +try { + $c = new Container("hello"); +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} +?> +--EXPECTF-- +%s::__construct(): Argument #1 ($value) must be of type int, string given, called in %s on line %d diff --git a/Zend/tests/generics/generic_function_basic.phpt b/Zend/tests/generics/generic_function_basic.phpt new file mode 100644 index 0000000000000..d4bd8628898ae --- /dev/null +++ b/Zend/tests/generics/generic_function_basic.phpt @@ -0,0 +1,16 @@ +--TEST-- +Generic function: basic declaration and invocation +--FILE-- +(T $value): T { + return $value; +} + +echo identity(42) . "\n"; +echo identity("hello") . "\n"; +echo identity(3.14) . "\n"; +?> +--EXPECT-- +42 +hello +3.14 diff --git a/Zend/tests/generics/generic_inheritance_arg_count_mismatch.phpt b/Zend/tests/generics/generic_inheritance_arg_count_mismatch.phpt new file mode 100644 index 0000000000000..735f9710d726a --- /dev/null +++ b/Zend/tests/generics/generic_inheritance_arg_count_mismatch.phpt @@ -0,0 +1,13 @@ +--TEST-- +Generic class: inheritance with wrong number of type arguments +--FILE-- + { + private $value; + public function __construct(T $value) { $this->value = $value; } +} + +class BadBox extends Box {} +?> +--EXPECTF-- +Fatal error: Class Box expects 1 generic type argument(s), 2 given in BadBox in %s on line %d diff --git a/Zend/tests/generics/generic_inheritance_method_resolution.phpt b/Zend/tests/generics/generic_inheritance_method_resolution.phpt new file mode 100644 index 0000000000000..0429a12bfd13d --- /dev/null +++ b/Zend/tests/generics/generic_inheritance_method_resolution.phpt @@ -0,0 +1,30 @@ +--TEST-- +Generic class: method signature resolution in inheritance +--FILE-- + { + private array $items = []; + public function add(T $item): void { $this->items[] = $item; } + public function first(): T { return $this->items[0]; } +} + +// Override with resolved concrete types — should be compatible +class IntList extends Collection { + public function add(int $item): void { + echo "IntList::add($item)\n"; + parent::add($item); + } + public function first(): int { + return parent::first(); + } +} + +$list = new IntList(); +$list->add(42); +echo $list->first() . "\n"; +echo "OK\n"; +?> +--EXPECT-- +IntList::add(42) +42 +OK diff --git a/Zend/tests/generics/generic_instanceof.phpt b/Zend/tests/generics/generic_instanceof.phpt new file mode 100644 index 0000000000000..fb7c95baea7f4 --- /dev/null +++ b/Zend/tests/generics/generic_instanceof.phpt @@ -0,0 +1,36 @@ +--TEST-- +Generic class: instanceof with generic type arguments +--FILE-- + { + public T $value; + public function __construct(T $value) { $this->value = $value; } +} + +$intBox = new Box(42); +$strBox = new Box("hello"); + +// instanceof without generic args (erasure) — always true for correct base class +var_dump($intBox instanceof Box); // true +var_dump($strBox instanceof Box); // true + +// instanceof with matching generic args +var_dump($intBox instanceof Box); // true +var_dump($strBox instanceof Box); // true + +// instanceof with non-matching generic args +var_dump($intBox instanceof Box); // false +var_dump($strBox instanceof Box); // false + +echo "OK\n"; +?> +--EXPECT-- +bool(true) +bool(true) +bool(true) +bool(true) +bool(false) +bool(false) +OK diff --git a/Zend/tests/generics/generic_interface_bad_override.phpt b/Zend/tests/generics/generic_interface_bad_override.phpt new file mode 100644 index 0000000000000..864cabaa0d4e6 --- /dev/null +++ b/Zend/tests/generics/generic_interface_bad_override.phpt @@ -0,0 +1,15 @@ +--TEST-- +Generic interface: incompatible implementation detected +--FILE-- + { + public function transform(T $input): T; +} + +// string is not compatible with int for Transformer +class BadTransformer implements Transformer { + public function transform(string $input): string { return $input; } +} +?> +--EXPECTF-- +Fatal error: Declaration of BadTransformer::transform(string $input): string must be compatible with Transformer::transform(T $input): T in %s on line %d diff --git a/Zend/tests/generics/generic_interface_basic.phpt b/Zend/tests/generics/generic_interface_basic.phpt new file mode 100644 index 0000000000000..c8eb6ce5de467 --- /dev/null +++ b/Zend/tests/generics/generic_interface_basic.phpt @@ -0,0 +1,13 @@ +--TEST-- +Generic interface: basic declaration +--FILE-- + { + public function add(T $item): void; + public function get(int $index): T; +} + +echo "Collection interface declared\n"; +?> +--EXPECT-- +Collection interface declared diff --git a/Zend/tests/generics/generic_interface_implementation.phpt b/Zend/tests/generics/generic_interface_implementation.phpt new file mode 100644 index 0000000000000..90781e0aa11fd --- /dev/null +++ b/Zend/tests/generics/generic_interface_implementation.phpt @@ -0,0 +1,27 @@ +--TEST-- +Generic interface: implementation with bound type arguments +--FILE-- + { + public function find(int $id): T; + public function save(T $entity): void; +} + +class UserRepo implements Repository { + private array $store = []; + public function find(int $id): string { return $this->store[$id] ?? "unknown"; } + public function save(string $entity): void { + $this->store[] = $entity; + echo "Saved: $entity\n"; + } +} + +$repo = new UserRepo(); +$repo->save("alice"); +echo $repo->find(0) . "\n"; +echo "OK\n"; +?> +--EXPECT-- +Saved: alice +alice +OK diff --git a/Zend/tests/generics/generic_nested.phpt b/Zend/tests/generics/generic_nested.phpt new file mode 100644 index 0000000000000..819badf344b7b --- /dev/null +++ b/Zend/tests/generics/generic_nested.phpt @@ -0,0 +1,39 @@ +--TEST-- +Generic class: nested generics with >> parsing and type enforcement +--FILE-- + { + public T $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +// Nested generics: Box> — tests >> parsing +$inner = new Box(42); +$outer = new Box>($inner); + +echo $outer->get()->get() . "\n"; + +// Wrong type on outer (expects Box, got string) +try { + $outer->value = "hello"; +} catch (TypeError $e) { + echo "outer: caught\n"; +} + +// Wrong type on inner (expects int, got string) +try { + $outer->get()->value = "hello"; +} catch (TypeError $e) { + echo "inner: caught\n"; +} + +echo "OK\n"; +?> +--EXPECT-- +42 +outer: caught +inner: caught +OK diff --git a/Zend/tests/generics/generic_promoted_property.phpt b/Zend/tests/generics/generic_promoted_property.phpt new file mode 100644 index 0000000000000..f5d157cd2c2c4 --- /dev/null +++ b/Zend/tests/generics/generic_promoted_property.phpt @@ -0,0 +1,53 @@ +--TEST-- +Generic class: promoted properties with generic type parameters +--FILE-- + { + public function __construct(public T $value) {} +} + +$intBox = new Box(42); +echo $intBox->value . "\n"; // 42 + +// Type enforcement on promoted property +try { + $intBox->value = "hello"; +} catch (TypeError $e) { + echo "Property error: " . $e->getMessage() . "\n"; +} + +// Constructor type enforcement +try { + $bad = new Box("hello"); +} catch (TypeError $e) { + echo "Constructor error: " . $e->getMessage() . "\n"; +} + +// Multiple promoted properties +class Pair { + public function __construct( + public A $first, + public B $second, + ) {} +} + +$p = new Pair("hello", 42); +echo $p->first . " " . $p->second . "\n"; + +try { + $p->first = 123; +} catch (TypeError $e) { + echo "Pair error: " . $e->getMessage() . "\n"; +} + +echo "OK\n"; +?> +--EXPECTF-- +42 +Property error: Cannot assign string to property Box::$value of type int +Constructor error: Box::__construct(): Argument #1 ($value) must be of type int, string given, called in %s on line %d +hello 42 +Pair error: Cannot assign int to property Pair::$first of type string +OK diff --git a/Zend/tests/generics/generic_reflection.phpt b/Zend/tests/generics/generic_reflection.phpt new file mode 100644 index 0000000000000..9c921f6e18c28 --- /dev/null +++ b/Zend/tests/generics/generic_reflection.phpt @@ -0,0 +1,108 @@ +--TEST-- +Generic class: Reflection API for generic parameters and type arguments +--FILE-- + { + public T $value; + public function __construct(T $value) { $this->value = $value; } +} + +class Container { + public function get(K $key): V { throw new \Exception("not impl"); } +} + +function identity(T $value): T { return $value; } + +// Test ReflectionClass::isGeneric() +$rc = new ReflectionClass(Box::class); +var_dump($rc->isGeneric()); // true + +$rc2 = new ReflectionClass(stdClass::class); +var_dump($rc2->isGeneric()); // false + +// Test ReflectionClass::getGenericParameters() +$params = $rc->getGenericParameters(); +echo "Box params count: " . count($params) . "\n"; +echo "Box param 0 name: " . $params[0]->getName() . "\n"; +echo "Box param 0 constraint: "; +var_dump($params[0]->getConstraint()); +echo "Box param 0 invariant: "; +var_dump($params[0]->isInvariant()); + +// Test Container +$rc3 = new ReflectionClass(Container::class); +$params3 = $rc3->getGenericParameters(); +echo "Container params count: " . count($params3) . "\n"; + +echo "K name: " . $params3[0]->getName() . "\n"; +echo "K invariant: "; +var_dump($params3[0]->isInvariant()); +echo "K covariant: "; +var_dump($params3[0]->isCovariant()); + +echo "V name: " . $params3[1]->getName() . "\n"; +echo "V covariant: "; +var_dump($params3[1]->isCovariant()); +echo "V contravariant: "; +var_dump($params3[1]->isContravariant()); +echo "V constraint: " . $params3[1]->getConstraint()->getName() . "\n"; + +// Test __toString +echo "K __toString: " . $params3[0] . "\n"; +echo "V __toString: " . $params3[1] . "\n"; + +// Test ReflectionObject::getGenericArguments() +$box = new Box(42); +$ro = new ReflectionObject($box); +var_dump($ro->isGeneric()); // true +$args = $ro->getGenericArguments(); +echo "Box args count: " . count($args) . "\n"; +echo "Box arg 0: " . $args[0]->getName() . "\n"; + +// Test non-generic object +$obj = new stdClass(); +$ro2 = new ReflectionObject($obj); +$args2 = $ro2->getGenericArguments(); +echo "stdClass args count: " . count($args2) . "\n"; + +// Test generic function reflection +$rf = new ReflectionFunction('identity'); +var_dump($rf->isGeneric()); // true +$fparams = $rf->getGenericParameters(); +echo "identity params count: " . count($fparams) . "\n"; +echo "identity param 0 name: " . $fparams[0]->getName() . "\n"; + +// Test non-generic function +$rf2 = new ReflectionFunction('strlen'); +var_dump($rf2->isGeneric()); // false + +echo "OK\n"; +?> +--EXPECT-- +bool(true) +bool(false) +Box params count: 1 +Box param 0 name: T +Box param 0 constraint: NULL +Box param 0 invariant: bool(true) +Container params count: 2 +K name: K +K invariant: bool(true) +K covariant: bool(false) +V name: V +V covariant: bool(true) +V contravariant: bool(false) +V constraint: Countable +K __toString: K +V __toString: out V: Countable +bool(true) +Box args count: 1 +Box arg 0: int +stdClass args count: 0 +bool(true) +identity params count: 1 +identity param 0 name: T +bool(false) +OK diff --git a/Zend/tests/generics/generic_trait_basic.phpt b/Zend/tests/generics/generic_trait_basic.phpt new file mode 100644 index 0000000000000..8945df52a6485 --- /dev/null +++ b/Zend/tests/generics/generic_trait_basic.phpt @@ -0,0 +1,47 @@ +--TEST-- +Generic trait: basic usage with bound type arguments +--FILE-- + { + public T $cached; + + public function cache(T $item): void { + $this->cached = $item; + } + + public function getCached(): T { + return $this->cached; + } +} + +class UserCache { + use Cacheable; +} + +$uc = new UserCache(); +$uc->cache("hello"); +echo $uc->getCached() . "\n"; + +// Wrong type on method arg should throw TypeError +try { + $uc->cache(42); +} catch (TypeError $e) { + echo "method: caught\n"; +} + +// Wrong type on property should throw TypeError +try { + $uc->cached = 42; +} catch (TypeError $e) { + echo "property: caught\n"; +} + +echo "OK\n"; +?> +--EXPECT-- +hello +method: caught +property: caught +OK diff --git a/Zend/tests/generics/generic_trait_multi_param.phpt b/Zend/tests/generics/generic_trait_multi_param.phpt new file mode 100644 index 0000000000000..9f384d44fcf5a --- /dev/null +++ b/Zend/tests/generics/generic_trait_multi_param.phpt @@ -0,0 +1,38 @@ +--TEST-- +Generic trait: multiple type parameters and return type resolution +--FILE-- + { + public function transform(In $input): Out { + return $this->doTransform($input); + } + + abstract protected function doTransform(In $input): Out; +} + +class StringToInt { + use Transform; + + protected function doTransform(string $input): int { + return strlen($input); + } +} + +$t = new StringToInt(); +echo $t->transform("hello") . "\n"; + +// Wrong input type +try { + $t->transform(42); +} catch (TypeError $e) { + echo "input: caught\n"; +} + +echo "OK\n"; +?> +--EXPECT-- +5 +input: caught +OK diff --git a/Zend/tests/generics/generic_trait_reflection.phpt b/Zend/tests/generics/generic_trait_reflection.phpt new file mode 100644 index 0000000000000..f3e4fa76d852e --- /dev/null +++ b/Zend/tests/generics/generic_trait_reflection.phpt @@ -0,0 +1,60 @@ +--TEST-- +Generic trait: Reflection API for generic trait parameters +--FILE-- + { + private T $cached; + public function cache(T $value): void { $this->cached = $value; } + public function getCached(): T { return $this->cached; } +} + +trait Transform { + abstract public function transform(In $input): Out; +} + +class UserCache { + use Cacheable; +} + +// Reflect the generic trait itself +$rt = new ReflectionClass('Cacheable'); +var_dump($rt->isGeneric()); // true +$params = $rt->getGenericParameters(); +echo "Cacheable params: " . count($params) . "\n"; +echo " T: " . $params[0]->getName() . "\n"; +echo " T invariant: "; +var_dump($params[0]->isInvariant()); + +// Reflect multi-param trait with variance +$rt2 = new ReflectionClass('Transform'); +var_dump($rt2->isGeneric()); // true +$params2 = $rt2->getGenericParameters(); +echo "Transform params: " . count($params2) . "\n"; +echo " In: " . $params2[0]->getName() . " invariant="; +var_dump($params2[0]->isInvariant()); +echo " Out: " . $params2[1]->getName() . " covariant="; +var_dump($params2[1]->isCovariant()); + +// Reflect the class using the generic trait +$rc = new ReflectionClass('UserCache'); +var_dump($rc->isGeneric()); // false (UserCache has no own type params) +echo "UserCache own params: " . count($rc->getGenericParameters()) . "\n"; +echo "UserCache traits: " . implode(', ', $rc->getTraitNames()) . "\n"; + +echo "OK\n"; +?> +--EXPECT-- +bool(true) +Cacheable params: 1 + T: T + T invariant: bool(true) +bool(true) +Transform params: 2 + In: In invariant=bool(true) + Out: Out covariant=bool(true) +bool(false) +UserCache own params: 0 +UserCache traits: Cacheable +OK diff --git a/Zend/tests/generics/generic_type_inference_basic.phpt b/Zend/tests/generics/generic_type_inference_basic.phpt new file mode 100644 index 0000000000000..1db15e81e40fd --- /dev/null +++ b/Zend/tests/generics/generic_type_inference_basic.phpt @@ -0,0 +1,43 @@ +--TEST-- +Generic class: type inference from constructor arguments +--FILE-- + { + private T $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } + public function set(T $value): void { $this->value = $value; } +} + +// Infer T=int from constructor arg +$box = new Box(42); +echo $box->get() . "\n"; + +// Should TypeError: T was inferred as int, string is incompatible +try { + $box->set("hello"); +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +// Infer T=string from constructor arg +$sbox = new Box("world"); +echo $sbox->get() . "\n"; + +// Should TypeError: T was inferred as string, int is incompatible (strict mode) +try { + $sbox->set(123); +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +echo "OK\n"; +?> +--EXPECTF-- +42 +Box::set(): Argument #1 ($value) must be of type int, string given, called in %s on line %d +world +Box::set(): Argument #1 ($value) must be of type string, int given, called in %s on line %d +OK diff --git a/Zend/tests/generics/generic_type_inference_multi_param.phpt b/Zend/tests/generics/generic_type_inference_multi_param.phpt new file mode 100644 index 0000000000000..5ca2137c2a58b --- /dev/null +++ b/Zend/tests/generics/generic_type_inference_multi_param.phpt @@ -0,0 +1,41 @@ +--TEST-- +Generic class: type inference with multiple type parameters +--FILE-- + { + public function __construct(private A $first, private B $second) {} + public function getFirst(): A { return $this->first; } + public function getSecond(): B { return $this->second; } + public function setFirst(A $value): void { $this->first = $value; } + public function setSecond(B $value): void { $this->second = $value; } +} + +// Infer A=int, B=string +$p = new Pair(1, "hello"); +echo $p->getFirst() . "\n"; +echo $p->getSecond() . "\n"; + +// Should TypeError: A was inferred as int +try { + $p->setFirst("bad"); +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +// Should TypeError: B was inferred as string +try { + $p->setSecond(42); +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +echo "OK\n"; +?> +--EXPECTF-- +1 +hello +Pair::setFirst(): Argument #1 ($value) must be of type int, string given, called in %s on line %d +Pair::setSecond(): Argument #1 ($value) must be of type string, int given, called in %s on line %d +OK diff --git a/Zend/tests/generics/generic_type_inference_weak_mode.phpt b/Zend/tests/generics/generic_type_inference_weak_mode.phpt new file mode 100644 index 0000000000000..90bfd9a75e0ab --- /dev/null +++ b/Zend/tests/generics/generic_type_inference_weak_mode.phpt @@ -0,0 +1,36 @@ +--TEST-- +Generic class: type inference respects weak type coercion rules +--FILE-- + { + private T $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } + public function set(T $value): void { $this->value = $value; } +} + +// Infer T=int +$box = new Box(42); + +// Non-numeric string cannot coerce to int even in weak mode +try { + $box->set("hello"); +} catch (TypeError $e) { + echo "Caught: non-numeric string to int\n"; +} + +// Infer T=string +$sbox = new Box("world"); + +// Int can coerce to string in weak mode — should succeed +$sbox->set(123); +echo "After set(123): " . $sbox->get() . "\n"; + +echo "OK\n"; +?> +--EXPECT-- +Caught: non-numeric string to int +After set(123): 123 +OK diff --git a/Zend/tests/generics/generic_typed_property.phpt b/Zend/tests/generics/generic_typed_property.phpt new file mode 100644 index 0000000000000..e2a22ebe99ec6 --- /dev/null +++ b/Zend/tests/generics/generic_typed_property.phpt @@ -0,0 +1,28 @@ +--TEST-- +Generic class: typed property with generic param +--FILE-- + { + private T $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } + public function set(T $value): void { $this->value = $value; } +} + +$box = new Box(42); +echo $box->get() . "\n"; + +$box->set(99); +echo $box->get() . "\n"; + +// Should TypeError: method argument type enforcement catches the wrong type +try { + $box->set("hello"); +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} +?> +--EXPECTF-- +42 +99 +Box::set(): Argument #1 ($value) must be of type int, string given, called in %s on line %d diff --git a/Zend/tests/generics/generic_typed_property_direct.phpt b/Zend/tests/generics/generic_typed_property_direct.phpt new file mode 100644 index 0000000000000..e7b9f2d47e4ad --- /dev/null +++ b/Zend/tests/generics/generic_typed_property_direct.phpt @@ -0,0 +1,27 @@ +--TEST-- +Generic class: direct typed property assignment enforcement +--FILE-- + { + public T $value; + public function __construct(T $value) { $this->value = $value; } +} + +$c = new Container(42); +echo $c->value . "\n"; + +// Direct property assignment with correct type +$c->value = 99; +echo $c->value . "\n"; + +// Direct property assignment with wrong type — should TypeError +try { + $c->value = "hello"; +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} +?> +--EXPECTF-- +42 +99 +Cannot assign string to property Container::$value of type int diff --git a/Zend/zend.h b/Zend/zend.h index ebb7d23919555..42797c9a45e0c 100644 --- a/Zend/zend.h +++ b/Zend/zend.h @@ -227,6 +227,17 @@ struct _zend_class_entry { uint32_t enum_backing_type; HashTable *backed_enum_table; + /* Generic type parameters (NULL for non-generic classes) */ + struct _zend_generic_params_info *generic_params_info; + /* Bound type arguments from parent (e.g., Collection when extending) */ + struct _zend_generic_args *bound_generic_args; + /* Bound type arguments for implemented interfaces. + * HashTable mapping lc_interface_name => zend_generic_args* */ + HashTable *interface_bound_generic_args; + /* Bound type arguments for used traits. + * HashTable mapping lc_trait_name => zend_generic_args* */ + HashTable *trait_bound_generic_args; + zend_string *doc_comment; union { diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 9d93c4d222518..60bdf0522b55c 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -137,7 +137,8 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_class_const_or_name(zend_ast * ZEND_API zend_ast *zend_ast_create_decl( zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment, - zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4 + zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4, + zend_ast *child5 ) { zend_ast_decl *ast; @@ -154,6 +155,7 @@ ZEND_API zend_ast *zend_ast_create_decl( ast->child[2] = child2; ast->child[3] = child3; ast->child[4] = child4; + ast->child[5] = child5; return (zend_ast *) ast; } @@ -1505,7 +1507,8 @@ ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast) zend_ast_destroy(decl->child[1]); zend_ast_destroy(decl->child[2]); zend_ast_destroy(decl->child[3]); - ast = decl->child[4]; + zend_ast_destroy(decl->child[4]); + ast = decl->child[5]; goto tail_call; } else if (EXPECTED(ast->kind == ZEND_AST_CALLABLE_CONVERT)) { zend_ast_fcc *fcc_ast = (zend_ast_fcc*) ast; diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index a88efefd85b20..d6df1af5df374 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -70,6 +70,8 @@ enum _zend_ast_kind { ZEND_AST_ATTRIBUTE_GROUP, ZEND_AST_MATCH_ARM_LIST, ZEND_AST_MODIFIER_LIST, + ZEND_AST_GENERIC_PARAMS, /* in declarations */ + ZEND_AST_GENERIC_ARGS, /* in type references */ /* 0 child nodes */ ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT, @@ -155,6 +157,8 @@ enum _zend_ast_kind { ZEND_AST_NAMED_ARG, ZEND_AST_PARENT_PROPERTY_HOOK_CALL, ZEND_AST_PIPE, + ZEND_AST_GENERIC_PARAM, /* child[0]=name(ZVAL), child[1]=constraint(type) or NULL */ + ZEND_AST_GENERIC_TYPE, /* child[0]=class_name, child[1]=ZEND_AST_GENERIC_ARGS list */ /* 3 child nodes */ ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT, @@ -227,7 +231,7 @@ typedef struct _zend_ast_decl { uint32_t flags; zend_string *doc_comment; zend_string *name; - zend_ast *child[5]; + zend_ast *child[6]; } zend_ast_decl; // TODO: rename @@ -339,7 +343,8 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_arg_list_add(zend_ast *list, zend_ast ZEND_API zend_ast *zend_ast_create_decl( zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment, - zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4 + zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2, zend_ast *child3, zend_ast *child4, + zend_ast *child5 ); ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_fcc(zend_ast *args); diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 23db72bb4fda1..d8b0a01474ef5 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -35,6 +35,7 @@ #include "zend_inheritance.h" #include "zend_vm.h" #include "zend_enum.h" +#include "zend_generics.h" #include "zend_observer.h" #include "zend_call_stack.h" #include "zend_frameless_function.h" @@ -102,6 +103,8 @@ static zend_op *zend_delayed_compile_var(znode *result, zend_ast *ast, uint32_t static void zend_compile_expr(znode *result, zend_ast *ast); static void zend_compile_stmt(zend_ast *ast); static void zend_compile_assign(znode *result, zend_ast *ast, bool stmt, uint32_t type); +static zend_type zend_compile_typename(zend_ast *ast); +static zend_type zend_compile_generic_type(zend_ast *ast); #ifdef ZEND_CHECK_STACK_LIMIT zend_never_inline static void zend_stack_limit_error(void) @@ -1445,6 +1448,46 @@ static zend_string *add_intersection_type(zend_string *str, zend_string *zend_type_to_string_resolved(const zend_type type, zend_class_entry *scope) { zend_string *str = NULL; + /* Handle generic type parameter (e.g., T) — resolve to concrete type if possible */ + if (ZEND_TYPE_IS_GENERIC_PARAM(type)) { + zend_generic_type_ref *ref = ZEND_TYPE_GENERIC_PARAM_REF(type); + /* Try to resolve from the current execution context */ + zend_generic_args *args = zend_get_current_generic_args(); + if (args && ref->param_index < args->num_args) { + zend_type resolved = args->args[ref->param_index]; + if (ZEND_TYPE_IS_SET(resolved)) { + return zend_type_to_string_resolved(resolved, scope); + } + } + return zend_string_copy(ref->name); + } + + /* Handle generic class type (e.g., Collection) */ + if (ZEND_TYPE_IS_GENERIC_CLASS(type)) { + zend_generic_class_ref *ref = ZEND_TYPE_GENERIC_CLASS_REF(type); + zend_string *result_str = zend_string_concat2( + ZSTR_VAL(ref->class_name), ZSTR_LEN(ref->class_name), "<", 1); + for (uint32_t i = 0; i < ref->type_args->num_args; i++) { + if (i > 0) { + zend_string *tmp = zend_string_concat2( + ZSTR_VAL(result_str), ZSTR_LEN(result_str), ", ", 2); + zend_string_release(result_str); + result_str = tmp; + } + zend_string *arg_str = zend_type_to_string_resolved(ref->type_args->args[i], scope); + zend_string *tmp = zend_string_concat2( + ZSTR_VAL(result_str), ZSTR_LEN(result_str), + ZSTR_VAL(arg_str), ZSTR_LEN(arg_str)); + zend_string_release(result_str); + zend_string_release(arg_str); + result_str = tmp; + } + zend_string *final = zend_string_concat2( + ZSTR_VAL(result_str), ZSTR_LEN(result_str), ">", 1); + zend_string_release(result_str); + return final; + } + /* Pure intersection type */ if (ZEND_TYPE_IS_INTERSECTION(type)) { ZEND_ASSERT(!ZEND_TYPE_IS_UNION(type)); @@ -2088,6 +2131,10 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, bool nullify_hand ce->attributes = NULL; ce->enum_backing_type = IS_UNDEF; ce->backed_enum_table = NULL; + ce->generic_params_info = NULL; + ce->bound_generic_args = NULL; + ce->interface_bound_generic_args = NULL; + ce->trait_bound_generic_args = NULL; if (nullify_handlers) { ce->constructor = NULL; @@ -5664,11 +5711,24 @@ static void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */ { zend_ast *class_ast = ast->child[0]; zend_ast *args_ast = ast->child[1]; + zend_generic_args *generic_args = NULL; znode class_node, ctor_result; zend_op *opline; - if (class_ast->kind == ZEND_AST_CLASS) { + if (class_ast->kind == ZEND_AST_GENERIC_TYPE) { + /* new Foo(...) — extract class name and compile generic args */ + zend_ast *real_class_ast = class_ast->child[0]; + zend_ast *type_args_ast = class_ast->child[1]; + zend_ast_list *type_args_list = zend_ast_get_list(type_args_ast); + + generic_args = zend_alloc_generic_args(type_args_list->children); + for (uint32_t i = 0; i < type_args_list->children; i++) { + generic_args->args[i] = zend_compile_typename(type_args_list->child[i]); + } + + zend_compile_class_ref(&class_node, real_class_ast, ZEND_FETCH_CLASS_EXCEPTION); + } else if (class_ast->kind == ZEND_AST_CLASS) { /* anon class declaration */ zend_compile_class_decl(&class_node, class_ast, false); } else { @@ -5681,6 +5741,23 @@ static void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */ if (opline->op1_type == IS_CONST) { opline->op2.num = zend_alloc_cache_slot(); + + if (generic_args) { + /* Store the generic_args pointer as a literal right after the class name literals. + * zend_add_class_name_literal adds 2 literals (name + lc_name), so the generic args + * literal is at op1.constant + 2. Signal its presence with high bit in op2.num. */ + zval generic_args_zv; + ZVAL_PTR(&generic_args_zv, generic_args); + zend_add_literal(&generic_args_zv); + opline->op2.num |= 0x80000000; + } + } else { + SET_NODE(opline->op1, &class_node); + if (generic_args) { + /* For non-const class references, we can't easily pass generic args. + * For Phase 1, free and ignore (only const class names get generic args). */ + zend_generic_args_dtor(generic_args); + } } zend_class_entry *ce = NULL; @@ -7363,6 +7440,12 @@ ZEND_API void zend_set_function_arg_flags(zend_function *func) /* {{{ */ static zend_type zend_compile_single_typename(zend_ast *ast) { ZEND_ASSERT(!(ast->attr & ZEND_TYPE_NULLABLE)); + + /* Handle ZEND_AST_GENERIC_TYPE (e.g., Collection) */ + if (ast->kind == ZEND_AST_GENERIC_TYPE) { + return zend_compile_generic_type(ast); + } + if (ast->kind == ZEND_AST_TYPE) { if (ast->attr == IS_STATIC && !CG(active_class_entry) && zend_is_scope_known()) { zend_error_noreturn(E_COMPILE_ERROR, @@ -7372,6 +7455,21 @@ static zend_type zend_compile_single_typename(zend_ast *ast) return (zend_type) ZEND_TYPE_INIT_CODE(ast->attr, 0, 0); } else { zend_string *type_name = zend_ast_get_str(ast); + + /* Check if this name refers to a generic type parameter (e.g., T, K, V) */ + if (CG(active_generic_params) && ast->attr == ZEND_NAME_NOT_FQ) { + zend_generic_params_info *gp = CG(active_generic_params); + for (uint32_t i = 0; i < gp->num_params; i++) { + if (zend_string_equals(type_name, gp->params[i].name)) { + zend_generic_type_ref *ref = emalloc(sizeof(zend_generic_type_ref)); + ref->name = zend_string_copy(type_name); + ref->param_index = i; + ref->variance = gp->params[i].variance; + return (zend_type) ZEND_TYPE_INIT_GENERIC_PARAM(ref, 0); + } + } + } + uint8_t type_code = zend_lookup_builtin_type_by_name(type_name); if (type_code != 0) { @@ -7531,8 +7629,6 @@ static void zend_is_type_list_redundant_by_single_type(const zend_type_list *typ } } -static zend_type zend_compile_typename(zend_ast *ast); - static zend_type zend_compile_typename_ex( zend_ast *ast, bool force_allow_null, bool *forced_allow_null) /* {{{ */ { @@ -8825,6 +8921,29 @@ static zend_op_array *zend_compile_func_decl_ex( CG(active_class_entry) = NULL; } + /* Compile generic type parameters (child[5]) for functions/methods */ + zend_generic_params_info *saved_generic_params = CG(active_generic_params); + if (decl->child[5] && (decl->kind == ZEND_AST_FUNC_DECL || decl->kind == ZEND_AST_METHOD + || decl->kind == ZEND_AST_CLOSURE || decl->kind == ZEND_AST_ARROW_FUNC)) { + /* For functions, we don't have a class entry, so we store generic params + * in a temporary allocation and set CG(active_generic_params) */ + zend_ast_list *gp_list = zend_ast_get_list(decl->child[5]); + uint32_t num_params = gp_list->children; + zend_generic_params_info *gp_info = zend_alloc_generic_params_info(num_params); + + for (uint32_t i = 0; i < num_params; i++) { + zend_ast *param_ast = gp_list->child[i]; + zend_ast *name_ast = param_ast->child[0]; + zend_ast *constraint_ast = param_ast->child[1]; + + gp_info->params[i].name = zend_string_copy(zend_ast_get_str(name_ast)); + if (constraint_ast) { + gp_info->params[i].constraint = zend_compile_typename(constraint_ast); + } + } + CG(active_generic_params) = gp_info; + } + if (level == FUNC_DECL_LEVEL_TOPLEVEL) { op_array->fn_flags |= ZEND_ACC_TOP_LEVEL; } @@ -8923,6 +9042,14 @@ static zend_op_array *zend_compile_func_decl_ex( CG(active_op_array) = orig_op_array; CG(active_class_entry) = orig_class_entry; + /* Store function-level generic params on the op_array (class-level ones are on the CE) */ + if (CG(active_generic_params) != saved_generic_params) { + op_array->generic_params_info = CG(active_generic_params); + } else { + op_array->generic_params_info = NULL; + } + CG(active_generic_params) = saved_generic_params; + return op_array; } @@ -9436,14 +9563,40 @@ static void zend_compile_use_trait(const zend_ast *ast) /* {{{ */ zend_ast *trait_ast = traits->child[i]; if (ce->ce_flags & ZEND_ACC_INTERFACE) { - zend_string *name = zend_ast_get_str(trait_ast); + zend_string *name = (trait_ast->kind == ZEND_AST_GENERIC_TYPE) + ? zend_ast_get_str(trait_ast->child[0]) : zend_ast_get_str(trait_ast); zend_error_noreturn(E_COMPILE_ERROR, "Cannot use traits inside of interfaces. " "%s is used in %s", ZSTR_VAL(name), ZSTR_VAL(ce->name)); } - ce->trait_names[ce->num_traits].name = - zend_resolve_const_class_name_reference(trait_ast, "trait name"); - ce->trait_names[ce->num_traits].lc_name = zend_string_tolower(ce->trait_names[ce->num_traits].name); + if (trait_ast->kind == ZEND_AST_GENERIC_TYPE) { + /* use Trait */ + zend_ast *name_ast = trait_ast->child[0]; + zend_ast *args_ast = trait_ast->child[1]; + + ce->trait_names[ce->num_traits].name = + zend_resolve_const_class_name_reference(name_ast, "trait name"); + ce->trait_names[ce->num_traits].lc_name = + zend_string_tolower(ce->trait_names[ce->num_traits].name); + + /* Compile generic type arguments and store in HashTable */ + if (!ce->trait_bound_generic_args) { + ALLOC_HASHTABLE(ce->trait_bound_generic_args); + zend_hash_init(ce->trait_bound_generic_args, traits->children, NULL, NULL, 0); + } + zend_ast_list *type_args = zend_ast_get_list(args_ast); + zend_generic_args *gargs = zend_alloc_generic_args(type_args->children); + for (uint32_t j = 0; j < type_args->children; j++) { + gargs->args[j] = zend_compile_typename(type_args->child[j]); + } + zend_hash_add_ptr(ce->trait_bound_generic_args, + ce->trait_names[ce->num_traits].lc_name, gargs); + } else { + ce->trait_names[ce->num_traits].name = + zend_resolve_const_class_name_reference(trait_ast, "trait name"); + ce->trait_names[ce->num_traits].lc_name = + zend_string_tolower(ce->trait_names[ce->num_traits].name); + } ce->num_traits++; } @@ -9477,9 +9630,33 @@ static void zend_compile_implements(zend_ast *ast) /* {{{ */ for (i = 0; i < list->children; ++i) { zend_ast *class_ast = list->child[i]; - interface_names[i].name = - zend_resolve_const_class_name_reference(class_ast, "interface name"); - interface_names[i].lc_name = zend_string_tolower(interface_names[i].name); + + if (class_ast->kind == ZEND_AST_GENERIC_TYPE) { + /* implements Interface */ + zend_ast *name_ast = class_ast->child[0]; + zend_ast *args_ast = class_ast->child[1]; + + interface_names[i].name = + zend_resolve_const_class_name_reference(name_ast, "interface name"); + interface_names[i].lc_name = zend_string_tolower(interface_names[i].name); + + /* Compile generic type arguments and store in HashTable */ + if (!ce->interface_bound_generic_args) { + ALLOC_HASHTABLE(ce->interface_bound_generic_args); + zend_hash_init(ce->interface_bound_generic_args, list->children, NULL, NULL, 0); + } + zend_ast_list *type_args = zend_ast_get_list(args_ast); + zend_generic_args *gargs = zend_alloc_generic_args(type_args->children); + for (uint32_t j = 0; j < type_args->children; j++) { + gargs->args[j] = zend_compile_typename(type_args->child[j]); + } + zend_hash_add_ptr(ce->interface_bound_generic_args, + interface_names[i].lc_name, gargs); + } else { + interface_names[i].name = + zend_resolve_const_class_name_reference(class_ast, "interface name"); + interface_names[i].lc_name = zend_string_tolower(interface_names[i].name); + } } ce->num_interfaces = list->children; @@ -9527,6 +9704,155 @@ static void zend_compile_enum_backing_type(zend_class_entry *ce, zend_ast *enum_ zend_type_release(type, 0); } +static void zend_compile_generic_params(zend_class_entry *ce, zend_ast *ast) /* {{{ */ +{ + zend_ast_list *list = zend_ast_get_list(ast); + uint32_t num_params = list->children; + + ce->generic_params_info = zend_alloc_generic_params_info(num_params); + + for (uint32_t i = 0; i < num_params; i++) { + zend_ast *param_ast = list->child[i]; + zend_ast *name_ast = param_ast->child[0]; + zend_ast *constraint_ast = param_ast->child[1]; + + zend_string *name = zend_string_copy(zend_ast_get_str(name_ast)); + ce->generic_params_info->params[i].name = name; + ce->generic_params_info->params[i].variance = (uint8_t) param_ast->attr; + + if (constraint_ast) { + /* Compile constraint as a class name type that we fully own. + * Don't intern or allocate ce_cache — constraints are only checked + * during generic arg validation, not on every type check. Using a + * non-interned copy ensures proper cleanup via zend_string_release. */ + zend_string *resolved = zend_resolve_class_name_ast(constraint_ast); + zend_string *constraint_name = zend_string_init( + ZSTR_VAL(resolved), ZSTR_LEN(resolved), 0); + zend_string_release(resolved); + ce->generic_params_info->params[i].constraint = + (zend_type) ZEND_TYPE_INIT_CLASS(constraint_name, /* allow null */ false, 0); + } + } +} +/* }}} */ + +/* Check that a generic type param with variance annotation is used in the correct position. + * covariant (out): only allowed in return types and readonly property types + * contravariant (in): only allowed in parameter types */ +static void zend_verify_generic_type_variance(zend_type type, bool is_return_position, + const char *context_desc, const zend_class_entry *ce) /* {{{ */ +{ + if (!ZEND_TYPE_IS_GENERIC_PARAM(type)) { + return; + } + zend_generic_type_ref *ref = ZEND_TYPE_GENERIC_PARAM_REF(type); + if (ref->variance == ZEND_GENERIC_VARIANCE_COVARIANT && !is_return_position) { + zend_error_noreturn(E_COMPILE_ERROR, + "Covariant type parameter %s of class %s cannot be used in %s (only return types allowed)", + ZSTR_VAL(ref->name), ZSTR_VAL(ce->name), context_desc); + } + if (ref->variance == ZEND_GENERIC_VARIANCE_CONTRAVARIANT && is_return_position) { + zend_error_noreturn(E_COMPILE_ERROR, + "Contravariant type parameter %s of class %s cannot be used in %s (only parameter types allowed)", + ZSTR_VAL(ref->name), ZSTR_VAL(ce->name), context_desc); + } +} +/* }}} */ + +static void zend_verify_generic_variance(zend_class_entry *ce) /* {{{ */ +{ + if (!ce->generic_params_info) { + return; + } + + /* Check if any params have variance annotations */ + bool has_variance = false; + for (uint32_t i = 0; i < ce->generic_params_info->num_params; i++) { + if (ce->generic_params_info->params[i].variance != ZEND_GENERIC_VARIANCE_INVARIANT) { + has_variance = true; + break; + } + } + if (!has_variance) { + return; + } + + /* Check all methods */ + zend_string *key; + zend_function *fn; + ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&ce->function_table, key, fn) { + if (fn->common.scope != ce) { + continue; /* Skip inherited methods */ + } + + /* Check parameter types — these are contravariant position (input) */ + uint32_t num_args = fn->common.num_args + ((fn->common.fn_flags & ZEND_ACC_VARIADIC) ? 1 : 0); + for (uint32_t i = 0; i < num_args; i++) { + char desc[256]; + snprintf(desc, sizeof(desc), "parameter $%s of method %s::%s()", + ZSTR_VAL(fn->common.arg_info[i].name), ZSTR_VAL(ce->name), + ZSTR_VAL(fn->common.function_name)); + zend_verify_generic_type_variance(fn->common.arg_info[i].type, + /* is_return_position */ false, desc, ce); + } + + /* Check return type — this is covariant position (output) */ + if (fn->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) { + char desc[256]; + snprintf(desc, sizeof(desc), "return type of method %s::%s()", + ZSTR_VAL(ce->name), ZSTR_VAL(fn->common.function_name)); + zend_verify_generic_type_variance(fn->common.arg_info[-1].type, + /* is_return_position */ true, desc, ce); + } + } ZEND_HASH_FOREACH_END(); + + /* Check property types — properties are invariant position by default, + * but readonly properties are covariant (output-only) */ + zend_property_info *prop; + ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, prop) { + if (prop->ce != ce) { + continue; + } + if (ZEND_TYPE_IS_GENERIC_PARAM(prop->type)) { + zend_generic_type_ref *ref = ZEND_TYPE_GENERIC_PARAM_REF(prop->type); + if (ref->variance != ZEND_GENERIC_VARIANCE_INVARIANT) { + bool is_readonly = (prop->flags & ZEND_ACC_READONLY) != 0; + if (ref->variance == ZEND_GENERIC_VARIANCE_COVARIANT && !is_readonly) { + zend_error_noreturn(E_COMPILE_ERROR, + "Covariant type parameter %s of class %s cannot be used for non-readonly property $%s", + ZSTR_VAL(ref->name), ZSTR_VAL(ce->name), ZSTR_VAL(prop->name)); + } + if (ref->variance == ZEND_GENERIC_VARIANCE_CONTRAVARIANT) { + zend_error_noreturn(E_COMPILE_ERROR, + "Contravariant type parameter %s of class %s cannot be used for property $%s", + ZSTR_VAL(ref->name), ZSTR_VAL(ce->name), ZSTR_VAL(prop->name)); + } + } + } + } ZEND_HASH_FOREACH_END(); +} +/* }}} */ + +static zend_type zend_compile_generic_type(zend_ast *ast) /* {{{ */ +{ + zend_ast *class_ast = ast->child[0]; + zend_ast *args_ast = ast->child[1]; + zend_ast_list *args_list = zend_ast_get_list(args_ast); + + zend_generic_class_ref *ref = emalloc(sizeof(zend_generic_class_ref)); + ref->class_name = zend_resolve_class_name_ast(class_ast); + ref->class_name = zend_new_interned_string(ref->class_name); + zend_alloc_ce_cache(ref->class_name); + + ref->type_args = zend_alloc_generic_args(args_list->children); + for (uint32_t i = 0; i < args_list->children; i++) { + ref->type_args->args[i] = zend_compile_typename(args_list->child[i]); + } + + return (zend_type) ZEND_TYPE_INIT_GENERIC_CLASS(ref, 0, 0); +} +/* }}} */ + static void zend_compile_class_decl(znode *result, const zend_ast *ast, bool toplevel) /* {{{ */ { const zend_ast_decl *decl = (const zend_ast_decl *) ast; @@ -9611,12 +9937,34 @@ static void zend_compile_class_decl(znode *result, const zend_ast *ast, bool top } if (extends_ast) { - ce->parent_name = - zend_resolve_const_class_name_reference(extends_ast, "class name"); + if (extends_ast->kind == ZEND_AST_GENERIC_TYPE) { + /* extends Foo */ + zend_ast *parent_name_ast = extends_ast->child[0]; + zend_ast *parent_args_ast = extends_ast->child[1]; + zend_ast_list *args_list = zend_ast_get_list(parent_args_ast); + + ce->parent_name = + zend_resolve_const_class_name_reference(parent_name_ast, "class name"); + + ce->bound_generic_args = zend_alloc_generic_args(args_list->children); + for (uint32_t i = 0; i < args_list->children; i++) { + ce->bound_generic_args->args[i] = zend_compile_typename(args_list->child[i]); + } + } else { + ce->parent_name = + zend_resolve_const_class_name_reference(extends_ast, "class name"); + } } CG(active_class_entry) = ce; + /* Compile generic type parameters (child[5]) */ + zend_generic_params_info *saved_generic_params = CG(active_generic_params); + if (decl->child[5]) { + zend_compile_generic_params(ce, decl->child[5]); + CG(active_generic_params) = ce->generic_params_info; + } + if (decl->child[3]) { zend_compile_attributes(&ce->attributes, decl->child[3], 0, ZEND_ATTRIBUTE_TARGET_CLASS, 0); } @@ -9642,7 +9990,11 @@ static void zend_compile_class_decl(znode *result, const zend_ast *ast, bool top zend_verify_abstract_class(ce); } + /* Validate variance annotations on generic type parameters */ + zend_verify_generic_variance(ce); + CG(active_class_entry) = original_ce; + CG(active_generic_params) = saved_generic_params; if (toplevel) { ce->ce_flags |= ZEND_ACC_TOP_LEVEL; @@ -11065,10 +11417,29 @@ static void zend_compile_instanceof(znode *result, zend_ast *ast) /* {{{ */ znode obj_node, class_node; zend_op *opline; + zend_generic_args *generic_args = NULL; + + /* Handle generic type: $x instanceof Collection */ + if (class_ast->kind == ZEND_AST_GENERIC_TYPE) { + zend_ast *name_ast = class_ast->child[0]; + zend_ast *args_ast = class_ast->child[1]; + + /* Compile generic type args */ + zend_ast_list *args_list = zend_ast_get_list(args_ast); + generic_args = zend_alloc_generic_args(args_list->children); + for (uint32_t i = 0; i < args_list->children; i++) { + generic_args->args[i] = zend_compile_typename(args_list->child[i]); + } + + class_ast = name_ast; /* Use just the class name for the base check */ + } zend_compile_expr(&obj_node, obj_ast); if (obj_node.op_type == IS_CONST) { zend_do_free(&obj_node); + if (generic_args) { + zend_generic_args_dtor(generic_args); + } result->op_type = IS_CONST; ZVAL_FALSE(&result->u.constant); return; @@ -11084,8 +11455,20 @@ static void zend_compile_instanceof(znode *result, zend_ast *ast) /* {{{ */ opline->op2.constant = zend_add_class_name_literal( Z_STR(class_node.u.constant)); opline->extended_value = zend_alloc_cache_slot(); + + if (generic_args) { + /* Store generic args pointer as a literal right after the class name literal */ + zval gargs_zv; + ZVAL_LONG(&gargs_zv, (zend_long)(uintptr_t)generic_args); + zend_add_literal(&gargs_zv); + opline->extended_value |= ZEND_INSTANCEOF_GENERIC_FLAG; + } } else { SET_NODE(opline->op2, &class_node); + if (generic_args) { + /* Dynamic class ref with generics — not yet supported, free args */ + zend_generic_args_dtor(generic_args); + } } } /* }}} */ diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h index 0b38084a107cd..7975ac3b95266 100644 --- a/Zend/zend_compile.h +++ b/Zend/zend_compile.h @@ -575,6 +575,9 @@ struct _zend_op_array { * referenced by index from opcodes. */ zend_op_array **dynamic_func_defs; + /* Generic type parameters for generic functions/methods (NULL for non-generic) */ + struct _zend_generic_params_info *generic_params_info; + void *reserved[ZEND_MAX_RESERVED_RESOURCES]; }; @@ -1052,6 +1055,9 @@ ZEND_API zend_string *zend_type_to_string(zend_type type); #define ZEND_FETCH_CLASS_ALLOW_UNLINKED 0x0400 #define ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED 0x0800 +/* Flag bit in ZEND_INSTANCEOF extended_value indicating generic type args are present */ +#define ZEND_INSTANCEOF_GENERIC_FLAG (1u << 30) + /* These should not clash with ZEND_ACC_PPP_MASK and ZEND_ACC_PPP_SET_MASK */ #define ZEND_PARAM_REF (1<<3) #define ZEND_PARAM_VARIADIC (1<<4) diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 37278c5cb9a23..9afd28a237bef 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -44,6 +44,7 @@ #include "zend_system_id.h" #include "zend_call_stack.h" #include "zend_attributes.h" +#include "zend_generics.h" #include "Optimizer/zend_func_info.h" /* Virtual current working directory support */ @@ -1037,9 +1038,64 @@ static bool zend_check_and_resolve_property_or_class_constant_class_type( return false; } -static zend_always_inline bool i_zend_check_property_type(const zend_property_info *info, zval *property, bool strict) +static zend_always_inline zend_generic_args *i_zend_get_generic_args_for_property(const zend_object *obj) +{ + /* First try the object's own generic args */ + if (obj) { + if (obj->generic_args) { + return obj->generic_args; + } + /* Fall back to class-level bound args (e.g., IntList extends Collection) */ + if (obj->ce->bound_generic_args) { + return obj->ce->bound_generic_args; + } + } + /* Fall back to execution context (for method calls on $this) */ + return zend_get_current_generic_args(); +} + +static zend_always_inline bool i_zend_check_property_type(const zend_property_info *info, zval *property, bool strict, const zend_object *obj) { ZEND_ASSERT(!Z_ISREF_P(property)); + + /* Handle generic type parameter (e.g., T $value in a generic class) */ + if (ZEND_TYPE_IS_GENERIC_PARAM(info->type)) { + zend_generic_type_ref *gref = ZEND_TYPE_GENERIC_PARAM_REF(info->type); + zend_generic_args *args = i_zend_get_generic_args_for_property(obj); + if (args && gref->param_index < args->num_args) { + zend_type resolved = args->args[gref->param_index]; + if (ZEND_TYPE_IS_SET(resolved)) { + /* Fast path: check type code directly (int, string, etc.) */ + if (ZEND_TYPE_CONTAINS_CODE(resolved, Z_TYPE_P(property))) { + return 1; + } + /* Class type: check instanceof */ + if (ZEND_TYPE_HAS_NAME(resolved) && Z_TYPE_P(property) == IS_OBJECT) { + zend_class_entry *ce = zend_lookup_class(ZEND_TYPE_NAME(resolved)); + if (ce && instanceof_function(Z_OBJCE_P(property), ce)) { + return 1; + } + } + /* Generic class type (e.g., Box): check instanceof + generic args */ + if (ZEND_TYPE_IS_GENERIC_CLASS(resolved) && Z_TYPE_P(property) == IS_OBJECT) { + zend_generic_class_ref *gcref = ZEND_TYPE_GENERIC_CLASS_REF(resolved); + zend_class_entry *expected_ce = zend_lookup_class(gcref->class_name); + if (expected_ce && instanceof_function(Z_OBJCE_P(property), expected_ce)) { + zend_generic_args *obj_args = Z_OBJ_P(property)->generic_args; + if (!gcref->type_args || !obj_args || zend_generic_args_compatible(gcref->type_args, obj_args, expected_ce->generic_params_info)) { + return 1; + } + } + return 0; + } + /* Try scalar coercion */ + return zend_verify_scalar_type_hint( + ZEND_TYPE_PURE_MASK(resolved), property, strict, 0); + } + } + return 1; /* unconstrained — allow any value */ + } + if (EXPECTED(ZEND_TYPE_CONTAINS_CODE(info->type, Z_TYPE_P(property)))) { return 1; } @@ -1054,21 +1110,44 @@ static zend_always_inline bool i_zend_check_property_type(const zend_property_in return zend_verify_scalar_type_hint(type_mask, property, strict, false); } -static zend_always_inline bool i_zend_verify_property_type(const zend_property_info *info, zval *property, bool strict) +static zend_always_inline bool i_zend_verify_property_type(const zend_property_info *info, zval *property, bool strict, const zend_object *obj) { - if (i_zend_check_property_type(info, property, strict)) { + if (i_zend_check_property_type(info, property, strict, obj)) { return 1; } + /* For generic param types, resolve T → concrete type name in error message */ + if (obj && ZEND_TYPE_IS_GENERIC_PARAM(info->type)) { + zend_generic_args *args = i_zend_get_generic_args_for_property(obj); + if (args) { + zend_generic_type_ref *gref = ZEND_TYPE_GENERIC_PARAM_REF(info->type); + if (gref->param_index < args->num_args) { + zend_type resolved = args->args[gref->param_index]; + zend_string *type_str = zend_type_to_string(resolved); + zend_type_error("Cannot assign %s to property %s::$%s of type %s", + zend_zval_value_name(property), + ZSTR_VAL(info->ce->name), + zend_get_unmangled_property_name(info->name), + ZSTR_VAL(type_str)); + zend_string_release(type_str); + return 0; + } + } + } + zend_verify_property_type_error(info, property); return 0; } ZEND_API bool zend_never_inline zend_verify_property_type(const zend_property_info *info, zval *property, bool strict) { - return i_zend_verify_property_type(info, property, strict); + return i_zend_verify_property_type(info, property, strict, NULL); +} + +ZEND_API bool zend_never_inline zend_verify_property_type_ex(const zend_property_info *info, zval *property, bool strict, const zend_object *obj) { + return i_zend_verify_property_type(info, property, strict, obj); } -static zend_never_inline zval* zend_assign_to_typed_prop(const zend_property_info *info, zval *property_val, zval *value, zend_refcounted **garbage_ptr EXECUTE_DATA_DC) +static zend_never_inline zval* zend_assign_to_typed_prop(const zend_property_info *info, zval *property_val, zval *value, zend_refcounted **garbage_ptr, const zend_object *obj EXECUTE_DATA_DC) { zval tmp; @@ -1086,7 +1165,7 @@ static zend_never_inline zval* zend_assign_to_typed_prop(const zend_property_inf ZVAL_DEREF(value); ZVAL_COPY(&tmp, value); - if (UNEXPECTED(!i_zend_verify_property_type(info, &tmp, EX_USES_STRICT_TYPES()))) { + if (UNEXPECTED(!i_zend_verify_property_type(info, &tmp, EX_USES_STRICT_TYPES(), obj))) { zval_ptr_dtor(&tmp); return &EG(uninitialized_zval); } @@ -1153,6 +1232,59 @@ static zend_always_inline bool zend_check_type_slow( const zend_type *type, zval *arg, const zend_reference *ref, bool is_return_type, bool is_internal) { + /* Handle generic type parameter references (e.g., T in a generic class) */ + if (ZEND_TYPE_IS_GENERIC_PARAM(*type)) { + zend_generic_type_ref *gref = ZEND_TYPE_GENERIC_PARAM_REF(*type); + zend_generic_args *args = zend_get_current_generic_args(); + + /* Lazy type inference: if no generic args are bound and we're in a + * constructor of a generic class, infer types from the actual arguments */ + if (!args && !is_return_type) { + zend_execute_data *ex = EG(current_execute_data); + if (ex && Z_TYPE(ex->This) == IS_OBJECT) { + zend_object *obj = Z_OBJ(ex->This); + if (obj->ce->generic_params_info && !obj->generic_args + && ex->func && ex->func->common.fn_flags & ZEND_ACC_CTOR) { + zend_infer_generic_args_from_constructor(obj, ex); + args = obj->generic_args; /* May be set now */ + } + } + } + + if (args && gref->param_index < args->num_args) { + zend_type resolved = args->args[gref->param_index]; + if (ZEND_TYPE_IS_SET(resolved)) { + /* Check against the resolved concrete type */ + if (ZEND_TYPE_CONTAINS_CODE(resolved, Z_TYPE_P(arg))) { + return true; + } + /* Recurse for complex type checks */ + return zend_check_type_slow(&resolved, arg, ref, is_return_type, is_internal); + } + } + /* No generic args bound — allow any value (unconstrained) */ + return true; + } + + /* Handle generic class type references (e.g., Collection as a type hint) */ + if (ZEND_TYPE_IS_GENERIC_CLASS(*type)) { + if (EXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) { + zend_generic_class_ref *gcref = ZEND_TYPE_GENERIC_CLASS_REF(*type); + zend_class_entry *expected_ce = zend_lookup_class(gcref->class_name); + if (!expected_ce || !instanceof_function(Z_OBJCE_P(arg), expected_ce)) { + return false; + } + /* Check generic args match (respecting variance) */ + zend_generic_args *obj_args = Z_OBJ_P(arg)->generic_args; + if (gcref->type_args && obj_args) { + return zend_generic_args_compatible(gcref->type_args, obj_args, expected_ce->generic_params_info); + } + /* If no generic args on the object, just check the base class */ + return true; + } + return false; + } + if (ZEND_TYPE_IS_COMPLEX(*type) && EXPECTED(Z_TYPE_P(arg) == IS_OBJECT)) { zend_class_entry *ce; if (UNEXPECTED(ZEND_TYPE_HAS_LIST(*type))) { @@ -4110,7 +4242,7 @@ ZEND_API bool ZEND_FASTCALL zend_verify_prop_assignable_by_ref_ex(const zend_pro } } else { ZVAL_DEREF(val); - if (i_zend_check_property_type(prop_info, val, strict)) { + if (i_zend_check_property_type(prop_info, val, strict, NULL)) { return 1; } } diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h index 89a9e79143a82..67a8bc91885fe 100644 --- a/Zend/zend_execute.h +++ b/Zend/zend_execute.h @@ -589,6 +589,7 @@ ZEND_API bool zend_verify_class_constant_type(const zend_class_constant *c, cons ZEND_COLD void zend_verify_class_constant_type_error(const zend_class_constant *c, const zend_string *name, const zval *constant); ZEND_API bool zend_verify_property_type(const zend_property_info *info, zval *property, bool strict); +ZEND_API bool zend_verify_property_type_ex(const zend_property_info *info, zval *property, bool strict, const zend_object *obj); ZEND_COLD void zend_verify_property_type_error(const zend_property_info *info, const zval *property); ZEND_COLD void zend_magic_get_property_type_inconsistency_error(const zend_property_info *info, const zval *property); diff --git a/Zend/zend_generics.c b/Zend/zend_generics.c new file mode 100644 index 0000000000000..23fdeb78de459 --- /dev/null +++ b/Zend/zend_generics.c @@ -0,0 +1,363 @@ +/* + +----------------------------------------------------------------------+ + | Zend Engine | + +----------------------------------------------------------------------+ + | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.00 of the Zend license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.zend.com/license/2_00.txt. | + | If you did not receive a copy of the Zend license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@zend.com so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ +*/ + +#include "zend.h" +#include "zend_generics.h" +#include "zend_type_info.h" +#include "zend_compile.h" +#include "zend_execute.h" + +ZEND_API zend_generic_params_info *zend_alloc_generic_params_info(uint32_t num_params) +{ + zend_generic_params_info *info = safe_emalloc( + num_params - 1, sizeof(zend_generic_param), + sizeof(zend_generic_params_info)); + info->num_params = num_params; + for (uint32_t i = 0; i < num_params; i++) { + info->params[i].name = NULL; + info->params[i].constraint = (zend_type) ZEND_TYPE_INIT_NONE(0); + info->params[i].variance = ZEND_GENERIC_VARIANCE_INVARIANT; + } + return info; +} + +ZEND_API zend_generic_args *zend_alloc_generic_args(uint32_t num_args) +{ + zend_generic_args *args = safe_emalloc( + num_args - 1, sizeof(zend_type), + sizeof(zend_generic_args)); + args->num_args = num_args; + for (uint32_t i = 0; i < num_args; i++) { + args->args[i] = (zend_type) ZEND_TYPE_INIT_NONE(0); + } + return args; +} + +ZEND_API zend_type zend_copy_generic_type(zend_type src) +{ + if (ZEND_TYPE_IS_GENERIC_CLASS(src)) { + /* Deep-copy the generic class ref */ + zend_generic_class_ref *orig = ZEND_TYPE_GENERIC_CLASS_REF(src); + zend_generic_class_ref *ref = emalloc(sizeof(zend_generic_class_ref)); + ref->class_name = zend_string_copy(orig->class_name); + ref->type_args = orig->type_args ? zend_copy_generic_args(orig->type_args) : NULL; + return (zend_type) ZEND_TYPE_INIT_GENERIC_CLASS(ref, 0, 0); + } + if (ZEND_TYPE_IS_GENERIC_PARAM(src)) { + /* Deep-copy the generic type ref */ + zend_generic_type_ref *orig = ZEND_TYPE_GENERIC_PARAM_REF(src); + zend_generic_type_ref *ref = emalloc(sizeof(zend_generic_type_ref)); + ref->name = zend_string_copy(orig->name); + ref->param_index = orig->param_index; + ref->variance = orig->variance; + return (zend_type) ZEND_TYPE_INIT_GENERIC_PARAM(ref, 0); + } + if (ZEND_TYPE_HAS_NAME(src)) { + zend_string_addref(ZEND_TYPE_NAME(src)); + } + return src; +} + +ZEND_API zend_generic_args *zend_copy_generic_args(const zend_generic_args *src) +{ + uint32_t num_args = src->num_args; + zend_generic_args *copy = safe_emalloc( + num_args - 1, sizeof(zend_type), + sizeof(zend_generic_args)); + copy->num_args = num_args; + for (uint32_t i = 0; i < num_args; i++) { + copy->args[i] = zend_copy_generic_type(src->args[i]); + } + return copy; +} + +ZEND_API void zend_generic_params_info_dtor(zend_generic_params_info *info) +{ + for (uint32_t i = 0; i < info->num_params; i++) { + if (info->params[i].name) { + zend_string_release(info->params[i].name); + } + zend_type_release(info->params[i].constraint, /* persistent */ 0); + } + efree(info); +} + +ZEND_API void zend_generic_args_dtor(zend_generic_args *args) +{ + for (uint32_t i = 0; i < args->num_args; i++) { + zend_type_release(args->args[i], /* persistent */ 0); + } + efree(args); +} + +ZEND_API void zend_generic_type_ref_dtor(zend_generic_type_ref *ref) +{ + if (ref->name) { + zend_string_release(ref->name); + } + efree(ref); +} + +ZEND_API void zend_generic_class_ref_dtor(zend_generic_class_ref *ref) +{ + if (ref->class_name) { + zend_string_release(ref->class_name); + } + if (ref->type_args) { + zend_generic_args_dtor(ref->type_args); + } + efree(ref); +} + +ZEND_API zend_type zend_resolve_generic_type(zend_type type, const zend_generic_args *args) +{ + if (ZEND_TYPE_IS_GENERIC_PARAM(type)) { + zend_generic_type_ref *ref = ZEND_TYPE_GENERIC_PARAM_REF(type); + if (args && ref->param_index < args->num_args) { + return args->args[ref->param_index]; + } + } + return type; +} + +ZEND_API bool zend_verify_generic_args( + const zend_generic_params_info *params, const zend_generic_args *args) +{ + if (args->num_args != params->num_params) { + zend_error(E_ERROR, + "Generic type expects %u type argument(s), %u given", + params->num_params, args->num_args); + return 0; + } + + for (uint32_t i = 0; i < params->num_params; i++) { + zend_type constraint = params->params[i].constraint; + if (!ZEND_TYPE_IS_SET(constraint)) { + continue; /* No constraint — any type is allowed */ + } + + /* Constraint is a class type — the type argument must be a class + * that implements/extends the constraint class. */ + if (ZEND_TYPE_HAS_NAME(constraint)) { + zend_string *constraint_name = ZEND_TYPE_NAME(constraint); + zend_class_entry *constraint_ce = zend_lookup_class(constraint_name); + if (!constraint_ce) { + zend_error(E_ERROR, + "Generic constraint class \"%s\" not found", + ZSTR_VAL(constraint_name)); + return 0; + } + + zend_type arg = args->args[i]; + /* The type arg must be a class type that satisfies the constraint */ + if (ZEND_TYPE_HAS_NAME(arg)) { + zend_class_entry *arg_ce = zend_lookup_class(ZEND_TYPE_NAME(arg)); + if (!arg_ce || !instanceof_function(arg_ce, constraint_ce)) { + zend_error(E_ERROR, + "Generic type argument #%u must implement %s, %s given", + i + 1, ZSTR_VAL(constraint_name), ZSTR_VAL(ZEND_TYPE_NAME(arg))); + return 0; + } + } else { + /* Primitive type (int, string, etc.) — cannot satisfy a class constraint */ + zend_string *arg_str = zend_type_to_string(arg); + zend_error(E_ERROR, + "Generic type argument #%u must implement %s, %s given", + i + 1, ZSTR_VAL(constraint_name), ZSTR_VAL(arg_str)); + zend_string_release(arg_str); + return 0; + } + } + } + return 1; +} + +/* Check if act_ce is a subclass of exp_ce (for covariant checks) */ +static bool zend_generic_type_is_subtype(zend_type expected, zend_type actual) +{ + /* Both are class types */ + if (ZEND_TYPE_HAS_NAME(expected) && ZEND_TYPE_HAS_NAME(actual)) { + zend_class_entry *exp_ce = zend_lookup_class(ZEND_TYPE_NAME(expected)); + zend_class_entry *act_ce = zend_lookup_class(ZEND_TYPE_NAME(actual)); + if (exp_ce && act_ce) { + return instanceof_function(act_ce, exp_ce); + } + } + return false; +} + +ZEND_API bool zend_generic_args_compatible( + const zend_generic_args *expected, const zend_generic_args *actual, + const zend_generic_params_info *params_info) +{ + if (expected == NULL && actual == NULL) { + return 1; + } + if (expected == NULL || actual == NULL) { + return 0; + } + if (expected->num_args != actual->num_args) { + return 0; + } + + for (uint32_t i = 0; i < expected->num_args; i++) { + zend_type exp_type = expected->args[i]; + zend_type act_type = actual->args[i]; + + /* Compare type masks for simple types */ + uint32_t exp_mask = ZEND_TYPE_PURE_MASK(exp_type); + uint32_t act_mask = ZEND_TYPE_PURE_MASK(act_type); + + if (exp_mask == act_mask) { + /* Same type code — check class names if present */ + if (ZEND_TYPE_HAS_NAME(exp_type) && ZEND_TYPE_HAS_NAME(act_type)) { + if (zend_string_equals_ci(ZEND_TYPE_NAME(exp_type), ZEND_TYPE_NAME(act_type))) { + continue; /* exact match */ + } + /* Names differ — check variance */ + uint8_t variance = (params_info && i < params_info->num_params) + ? params_info->params[i].variance : ZEND_GENERIC_VARIANCE_INVARIANT; + + if (variance == ZEND_GENERIC_VARIANCE_COVARIANT) { + /* out T: actual must be subtype of expected (e.g., Dog is subtype of Animal) */ + if (zend_generic_type_is_subtype(exp_type, act_type)) { + continue; + } + } else if (variance == ZEND_GENERIC_VARIANCE_CONTRAVARIANT) { + /* in T: actual must be supertype of expected (e.g., Animal is supertype of Dog) */ + if (zend_generic_type_is_subtype(act_type, exp_type)) { + continue; + } + } + return 0; + } else if (ZEND_TYPE_HAS_NAME(exp_type) != ZEND_TYPE_HAS_NAME(act_type)) { + return 0; + } + } else { + return 0; + } + } + return 1; +} + +ZEND_API zend_type zend_infer_type_from_zval(const zval *value) +{ + switch (Z_TYPE_P(value)) { + case IS_LONG: + return (zend_type) ZEND_TYPE_INIT_CODE(IS_LONG, 0, 0); + case IS_DOUBLE: + return (zend_type) ZEND_TYPE_INIT_CODE(IS_DOUBLE, 0, 0); + case IS_STRING: + return (zend_type) ZEND_TYPE_INIT_CODE(IS_STRING, 0, 0); + case IS_TRUE: + case IS_FALSE: + return (zend_type) ZEND_TYPE_INIT_CODE(_IS_BOOL, 0, 0); + case IS_ARRAY: + return (zend_type) ZEND_TYPE_INIT_CODE(IS_ARRAY, 0, 0); + case IS_OBJECT: { + zend_string *class_name = zend_string_copy(Z_OBJCE_P(value)->name); + return (zend_type) ZEND_TYPE_INIT_CLASS(class_name, 0, 0); + } + case IS_NULL: + return (zend_type) ZEND_TYPE_INIT_CODE(IS_NULL, 0, 0); + default: + return (zend_type) ZEND_TYPE_INIT_NONE(0); + } +} + +ZEND_API bool zend_infer_generic_args_from_constructor(zend_object *obj, zend_execute_data *call) +{ + zend_class_entry *ce = obj->ce; + if (!ce->generic_params_info || obj->generic_args) { + return false; /* Not a generic class or already has args */ + } + + zend_function *ctor = ce->constructor; + if (!ctor) { + return false; + } + + uint32_t num_params = ce->generic_params_info->num_params; + zend_generic_args *inferred = zend_alloc_generic_args(num_params); + + /* Scan constructor parameters for generic type params and infer from actual args */ + uint32_t num_ctor_args = ctor->common.num_args; + uint32_t num_call_args = ZEND_CALL_NUM_ARGS(call); + + for (uint32_t i = 0; i < num_ctor_args && i < num_call_args; i++) { + zend_arg_info *arg_info = &ctor->common.arg_info[i]; + if (ZEND_TYPE_IS_GENERIC_PARAM(arg_info->type)) { + zend_generic_type_ref *gref = ZEND_TYPE_GENERIC_PARAM_REF(arg_info->type); + if (gref->param_index < num_params && !ZEND_TYPE_IS_SET(inferred->args[gref->param_index])) { + zval *arg_val = ZEND_CALL_VAR_NUM(call, i); + zend_type inferred_type = zend_infer_type_from_zval(arg_val); + if (ZEND_TYPE_IS_SET(inferred_type)) { + inferred->args[gref->param_index] = inferred_type; + } + } + } + } + + /* Check that all type params got inferred */ + bool all_inferred = true; + for (uint32_t i = 0; i < num_params; i++) { + if (!ZEND_TYPE_IS_SET(inferred->args[i])) { + all_inferred = false; + break; + } + } + + if (!all_inferred) { + /* Could not infer all type params — free and leave unbound */ + zend_generic_args_dtor(inferred); + return false; + } + + /* Validate against constraints */ + if (!zend_verify_generic_args(ce->generic_params_info, inferred)) { + zend_generic_args_dtor(inferred); + return false; + } + + obj->generic_args = inferred; + return true; +} + +ZEND_API zend_generic_args *zend_get_current_generic_args(void) +{ + zend_execute_data *ex = EG(current_execute_data); + + if (!ex) { + return NULL; + } + + /* For method calls: get from the object instance */ + if (Z_TYPE(ex->This) == IS_OBJECT) { + zend_object *obj = Z_OBJ(ex->This); + if (obj->generic_args) { + return obj->generic_args; + } + /* Fall back to class-level bound args (e.g., IntList extends Collection) */ + if (obj->ce->bound_generic_args) { + return obj->ce->bound_generic_args; + } + } + + /* For generic functions: stored in extra named args or similar mechanism */ + /* Phase 1: function-level generics use a simpler approach */ + + return NULL; +} diff --git a/Zend/zend_generics.h b/Zend/zend_generics.h new file mode 100644 index 0000000000000..58e42da443eb9 --- /dev/null +++ b/Zend/zend_generics.h @@ -0,0 +1,99 @@ +/* + +----------------------------------------------------------------------+ + | Zend Engine | + +----------------------------------------------------------------------+ + | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) | + +----------------------------------------------------------------------+ + | This source file is subject to version 2.00 of the Zend license, | + | that is bundled with this package in the file LICENSE, and is | + | available through the world-wide-web at the following url: | + | http://www.zend.com/license/2_00.txt. | + | If you did not receive a copy of the Zend license and are unable to | + | obtain it through the world-wide-web, please send a note to | + | license@zend.com so we can mail you a copy immediately. | + +----------------------------------------------------------------------+ +*/ + +#ifndef ZEND_GENERICS_H +#define ZEND_GENERICS_H + +#include "zend_types.h" +#include "zend_string.h" + +/* Variance annotations for generic type parameters */ +#define ZEND_GENERIC_VARIANCE_INVARIANT 0 /* default: no variance */ +#define ZEND_GENERIC_VARIANCE_COVARIANT 1 /* "out T" — only in return positions */ +#define ZEND_GENERIC_VARIANCE_CONTRAVARIANT 2 /* "in T" — only in parameter positions */ + +/* A single generic type parameter declaration (e.g., "T", "T: Countable", "out T") */ +typedef struct _zend_generic_param { + zend_string *name; /* "T", "K", "V", etc. */ + zend_type constraint; /* Bound type (e.g., Countable), or IS_UNDEF */ + uint8_t variance; /* ZEND_GENERIC_VARIANCE_* */ +} zend_generic_param; + +/* Generic parameters info attached to a generic class/function. + * Variable-length struct: params[0..num_params-1]. */ +typedef struct _zend_generic_params_info { + uint32_t num_params; + zend_generic_param params[1]; /* Flexible array */ +} zend_generic_params_info; + +/* Bound generic type arguments (e.g., ). + * Variable-length struct: args[0..num_args-1]. */ +typedef struct _zend_generic_args { + uint32_t num_args; + zend_type args[1]; /* Flexible array */ +} zend_generic_args; + +/* Reference to a generic type parameter in a zend_type. + * Stored in zend_type.ptr when MAY_BE_GENERIC_PARAM is set. */ +typedef struct _zend_generic_type_ref { + zend_string *name; /* "T" — for error messages */ + uint32_t param_index; /* Index into generic_params_info */ + uint8_t variance; /* ZEND_GENERIC_VARIANCE_* (copied from param decl) */ +} zend_generic_type_ref; + +/* A class type reference with generic arguments (e.g., Collection). + * Stored in zend_type.ptr when _ZEND_TYPE_GENERIC_CLASS_BIT is set. */ +typedef struct _zend_generic_class_ref { + zend_string *class_name; + zend_generic_args *type_args; +} zend_generic_class_ref; + +/* Allocation */ +ZEND_API zend_generic_params_info *zend_alloc_generic_params_info(uint32_t num_params); +ZEND_API zend_generic_args *zend_alloc_generic_args(uint32_t num_args); +ZEND_API zend_type zend_copy_generic_type(zend_type src); +ZEND_API zend_generic_args *zend_copy_generic_args(const zend_generic_args *src); + +/* Destruction */ +ZEND_API void zend_generic_params_info_dtor(zend_generic_params_info *info); +ZEND_API void zend_generic_args_dtor(zend_generic_args *args); +ZEND_API void zend_generic_type_ref_dtor(zend_generic_type_ref *ref); +ZEND_API void zend_generic_class_ref_dtor(zend_generic_class_ref *ref); + +/* Resolution: resolves a generic type param to its concrete type */ +ZEND_API zend_type zend_resolve_generic_type(zend_type type, const zend_generic_args *args); + +/* Validation: checks that generic args satisfy constraints */ +ZEND_API bool zend_verify_generic_args( + const zend_generic_params_info *params, const zend_generic_args *args); + +/* Comparison: checks if two sets of generic args are compatible. + * params_info is optional (may be NULL) — when provided, variance annotations are respected. */ +ZEND_API bool zend_generic_args_compatible( + const zend_generic_args *expected, const zend_generic_args *actual, + const zend_generic_params_info *params_info); + +/* Infer a zend_type from a runtime zval value */ +ZEND_API zend_type zend_infer_type_from_zval(const zval *value); + +/* Infer generic type args from constructor call arguments. + * Returns true if inference succeeded and args were bound to the object. */ +ZEND_API bool zend_infer_generic_args_from_constructor(zend_object *obj, zend_execute_data *call); + +/* Get current generic args from execution context */ +ZEND_API zend_generic_args *zend_get_current_generic_args(void); + +#endif /* ZEND_GENERICS_H */ diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h index 31f54cd8284b7..431e51edb9b1c 100644 --- a/Zend/zend_globals.h +++ b/Zend/zend_globals.h @@ -158,6 +158,9 @@ struct _zend_compiler_globals { uint32_t internal_run_time_cache_size; zend_stack short_circuiting_opnums; + + /* Generic type parameters currently in scope during compilation */ + struct _zend_generic_params_info *active_generic_params; #ifdef ZTS uint32_t copied_functions_count; #endif @@ -222,6 +225,9 @@ struct _zend_executor_globals { HashTable autoload_current_classnames; + /* Generic args for current static method call context (e.g., Collection::create()) */ + struct _zend_generic_args *static_generic_args; + zend_long hard_timeout; void *stack_base; void *stack_limit; @@ -389,6 +395,12 @@ struct _zend_php_scanner_globals { /* initial string length after scanning to first variable */ int scanned_string_len; + /* Last token returned by the lexer (for generic '<' disambiguation) */ + int last_token; + + /* Nesting depth of generic angle brackets (for >> splitting) */ + int generic_depth; + /* hooks */ void (*on_event)( zend_php_scanner_event event, int token, int line, diff --git a/Zend/zend_inheritance.c b/Zend/zend_inheritance.c index 557a99bc871d9..730ec09b7eab7 100644 --- a/Zend/zend_inheritance.c +++ b/Zend/zend_inheritance.c @@ -31,6 +31,7 @@ #include "zend_attributes.h" #include "zend_constants.h" #include "zend_observer.h" +#include "zend_generics.h" ZEND_API zend_class_entry* (*zend_inheritance_cache_get)(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces) = NULL; ZEND_API zend_class_entry* (*zend_inheritance_cache_add)(zend_class_entry *ce, zend_class_entry *proto, zend_class_entry *parent, zend_class_entry **traits_and_interfaces, HashTable *dependencies) = NULL; @@ -830,6 +831,36 @@ static inheritance_status zend_do_perform_implementation_check( fe_num_args = fe->common.num_args + fe_is_variadic; num_args = MAX(proto_num_args, fe_num_args); + /* Get bound generic args for resolving parent's generic type params. + * When IntList extends Collection, fe_scope->bound_generic_args = [int], + * so parent's T (param_index=0) resolves to int. + * For interfaces: look up in interface_bound_generic_args HashTable by name. + * For traits: look up in trait_bound_generic_args HashTable by name. */ + const zend_generic_args *bound_args = NULL; + if (fe_scope) { + if (proto_scope && proto_scope->name && fe_scope->interface_bound_generic_args) { + zend_string *lc_name = zend_string_tolower(proto_scope->name); + zend_generic_args *iface_args = zend_hash_find_ptr( + fe_scope->interface_bound_generic_args, lc_name); + zend_string_release(lc_name); + if (iface_args) { + bound_args = iface_args; + } + } + if (!bound_args && proto_scope && proto_scope->name && fe_scope->trait_bound_generic_args) { + zend_string *lc_name = zend_string_tolower(proto_scope->name); + zend_generic_args *trait_args = zend_hash_find_ptr( + fe_scope->trait_bound_generic_args, lc_name); + zend_string_release(lc_name); + if (trait_args) { + bound_args = trait_args; + } + } + if (!bound_args) { + bound_args = fe_scope->bound_generic_args; + } + } + status = INHERITANCE_SUCCESS; for (uint32_t i = 0; i < num_args; i++) { zend_arg_info *proto_arg_info = @@ -849,8 +880,20 @@ static inheritance_status zend_do_perform_implementation_check( return INHERITANCE_ERROR; } + /* Resolve generic type params in parent's arg type using child's bound args */ + zend_arg_info resolved_proto_arg; + zend_arg_info *effective_proto = proto_arg_info; + if (bound_args && ZEND_TYPE_IS_GENERIC_PARAM(proto_arg_info->type)) { + zend_type resolved = zend_resolve_generic_type(proto_arg_info->type, bound_args); + if (!ZEND_TYPE_IS_GENERIC_PARAM(resolved)) { + resolved_proto_arg = *proto_arg_info; + resolved_proto_arg.type = resolved; + effective_proto = &resolved_proto_arg; + } + } + local_status = zend_do_perform_arg_type_hint_check( - fe_scope, fe_arg_info, proto_scope, proto_arg_info); + fe_scope, fe_arg_info, proto_scope, effective_proto); if (UNEXPECTED(local_status != INHERITANCE_SUCCESS)) { if (UNEXPECTED(local_status == INHERITANCE_ERROR)) { @@ -880,8 +923,17 @@ static inheritance_status zend_do_perform_implementation_check( return status; } + /* Resolve generic type params in parent's return type */ + zend_type proto_return_type = proto->common.arg_info[-1].type; + if (bound_args && ZEND_TYPE_IS_GENERIC_PARAM(proto_return_type)) { + zend_type resolved = zend_resolve_generic_type(proto_return_type, bound_args); + if (!ZEND_TYPE_IS_GENERIC_PARAM(resolved)) { + proto_return_type = resolved; + } + } + local_status = zend_perform_covariant_type_check( - fe_scope, fe->common.arg_info[-1].type, proto_scope, proto->common.arg_info[-1].type); + fe_scope, fe->common.arg_info[-1].type, proto_scope, proto_return_type); if (UNEXPECTED(local_status != INHERITANCE_SUCCESS)) { if (local_status == INHERITANCE_ERROR @@ -1881,6 +1933,22 @@ ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *par ce->default_object_handlers = parent_ce->default_object_handlers; ce->ce_flags |= ZEND_ACC_RESOLVED_PARENT; + /* Validate generic type arguments against parent's generic parameters */ + if (parent_ce->generic_params_info) { + if (ce->bound_generic_args) { + if (ce->bound_generic_args->num_args != parent_ce->generic_params_info->num_params) { + zend_error_noreturn(E_COMPILE_ERROR, + "Class %s expects %u generic type argument(s), %u given in %s", + ZSTR_VAL(parent_ce->name), + parent_ce->generic_params_info->num_params, + ce->bound_generic_args->num_args, + ZSTR_VAL(ce->name)); + } + } + /* Note: If parent is generic and child doesn't provide args, that's allowed + * for Phase 1 — the type params remain unbound. */ + } + /* Inherit properties */ if (parent_ce->default_properties_count) { zval *src, *dst, *end; @@ -2448,7 +2516,63 @@ static void zend_traits_check_private_final_inheritance(uint32_t original_fn_fla } } -static void zend_traits_copy_functions(zend_string *fnname, zend_function *fn, zend_class_entry *ce, HashTable *exclude_table, zend_class_entry **aliases) /* {{{ */ +/* Resolve generic type parameters in a trait method's arg_info when copying + * into a class that uses the trait with bound type arguments. + * E.g., trait Cacheable { public function cache(T $item): T; } + * class Foo { use Cacheable; } + * After resolution, Foo::cache has arg type User and return type User. */ +static void zend_resolve_trait_method_generics(zend_function *fn, const zend_generic_args *bound_args) /* {{{ */ +{ + uint32_t num_args = fn->common.num_args + ((fn->common.fn_flags & ZEND_ACC_VARIADIC) ? 1 : 0); + bool has_return_type = (fn->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) != 0; + bool needs_resolution = false; + + /* Check if any types need resolution */ + if (has_return_type && ZEND_TYPE_IS_GENERIC_PARAM(fn->common.arg_info[-1].type)) { + needs_resolution = true; + } + if (!needs_resolution) { + for (uint32_t i = 0; i < num_args; i++) { + if (ZEND_TYPE_IS_GENERIC_PARAM(fn->common.arg_info[i].type)) { + needs_resolution = true; + break; + } + } + } + if (!needs_resolution) { + return; + } + + /* Allocate new arg_info in arena: num_args + 1 for return type slot at [-1] */ + zend_arg_info *new_arg_info_base = zend_arena_alloc(&CG(arena), + (num_args + 1) * sizeof(zend_arg_info)); + zend_arg_info *new_arg_info = new_arg_info_base + 1; + + /* Copy return type info (at index -1) */ + new_arg_info[-1] = fn->common.arg_info[-1]; + if (has_return_type && ZEND_TYPE_IS_GENERIC_PARAM(fn->common.arg_info[-1].type)) { + zend_type resolved = zend_resolve_generic_type(fn->common.arg_info[-1].type, bound_args); + if (!ZEND_TYPE_IS_GENERIC_PARAM(resolved)) { + new_arg_info[-1].type = zend_copy_generic_type(resolved); + } + } + + /* Copy and resolve argument types */ + for (uint32_t i = 0; i < num_args; i++) { + new_arg_info[i] = fn->common.arg_info[i]; + if (ZEND_TYPE_IS_GENERIC_PARAM(fn->common.arg_info[i].type)) { + zend_type resolved = zend_resolve_generic_type(fn->common.arg_info[i].type, bound_args); + if (!ZEND_TYPE_IS_GENERIC_PARAM(resolved)) { + new_arg_info[i].type = zend_copy_generic_type(resolved); + } + } + } + + fn->common.arg_info = new_arg_info; +} +/* }}} */ + +static void zend_traits_copy_functions(zend_string *fnname, zend_function *fn, zend_class_entry *ce, HashTable *exclude_table, zend_class_entry **aliases, const zend_generic_args *trait_bound_args) /* {{{ */ { zend_trait_alias *alias, **alias_ptr; zend_function fn_copy; @@ -2472,6 +2596,11 @@ static void zend_traits_copy_functions(zend_string *fnname, zend_function *fn, z fn_copy.common.fn_flags = alias->modifiers | fn->common.fn_flags; } + /* Resolve generic type params in trait method signatures */ + if (trait_bound_args) { + zend_resolve_trait_method_generics(&fn_copy, trait_bound_args); + } + zend_traits_check_private_final_inheritance(fn->common.fn_flags, &fn_copy, alias->alias); zend_string *lcname = zend_string_tolower(alias->alias); @@ -2511,6 +2640,11 @@ static void zend_traits_copy_functions(zend_string *fnname, zend_function *fn, z } } + /* Resolve generic type params in trait method signatures */ + if (trait_bound_args) { + zend_resolve_trait_method_generics(&fn_copy, trait_bound_args); + } + zend_traits_check_private_final_inheritance(fn->common.fn_flags, &fn_copy, fnname); zend_add_trait_method(ce, fn->common.function_name, fnname, &fn_copy); @@ -2696,6 +2830,14 @@ static void zend_do_traits_method_binding(zend_class_entry *ce, zend_class_entry if (exclude_tables) { for (i = 0; i < ce->num_traits; i++) { if (traits[i]) { + /* Look up bound generic args for this trait */ + const zend_generic_args *trait_bound_args = NULL; + if (ce->trait_bound_generic_args && traits[i]->name) { + zend_string *lc_name = zend_string_tolower(traits[i]->name); + trait_bound_args = zend_hash_find_ptr(ce->trait_bound_generic_args, lc_name); + zend_string_release(lc_name); + } + /* copies functions, applies defined aliasing, and excludes unused trait methods */ ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) { bool is_abstract = (bool) (fn->common.fn_flags & ZEND_ACC_ABSTRACT); @@ -2703,7 +2845,7 @@ static void zend_do_traits_method_binding(zend_class_entry *ce, zend_class_entry if (verify_abstract != is_abstract) { continue; } - zend_traits_copy_functions(key, fn, ce, exclude_tables[i], aliases); + zend_traits_copy_functions(key, fn, ce, exclude_tables[i], aliases, trait_bound_args); } ZEND_HASH_FOREACH_END(); if (exclude_tables[i]) { @@ -2716,13 +2858,21 @@ static void zend_do_traits_method_binding(zend_class_entry *ce, zend_class_entry } else { for (i = 0; i < ce->num_traits; i++) { if (traits[i]) { + /* Look up bound generic args for this trait */ + const zend_generic_args *trait_bound_args = NULL; + if (ce->trait_bound_generic_args && traits[i]->name) { + zend_string *lc_name = zend_string_tolower(traits[i]->name); + trait_bound_args = zend_hash_find_ptr(ce->trait_bound_generic_args, lc_name); + zend_string_release(lc_name); + } + ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) { bool is_abstract = (bool) (fn->common.fn_flags & ZEND_ACC_ABSTRACT); *contains_abstract_methods |= is_abstract; if (verify_abstract != is_abstract) { continue; } - zend_traits_copy_functions(key, fn, ce, NULL, aliases); + zend_traits_copy_functions(key, fn, ce, NULL, aliases, trait_bound_args); } ZEND_HASH_FOREACH_END(); } } @@ -2958,6 +3108,21 @@ static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_ent zend_string *doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL; zend_type type = property_info->type; + + /* Resolve generic type params in trait property types */ + if (ZEND_TYPE_IS_GENERIC_PARAM(type) && ce->trait_bound_generic_args && traits[i]->name) { + zend_string *lc_trait_name = zend_string_tolower(traits[i]->name); + const zend_generic_args *trait_gargs = zend_hash_find_ptr( + ce->trait_bound_generic_args, lc_trait_name); + zend_string_release(lc_trait_name); + if (trait_gargs) { + zend_type resolved = zend_resolve_generic_type(type, trait_gargs); + if (!ZEND_TYPE_IS_GENERIC_PARAM(resolved)) { + type = resolved; + } + } + } + /* Assumption: only userland classes can use traits, as such the type must be arena allocated */ zend_type_copy_ctor(&type, /* use arena */ true, /* persistent */ false); zend_property_info *new_prop = zend_declare_typed_property(ce, prop_name, prop_value, flags, doc_comment, type); diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index e2686c7e1c5a8..e3a70aff8a5d1 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -40,6 +40,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %code requires { #include "zend_compile.h" +#include "zend_generics.h" } %define api.prefix {zend} @@ -248,6 +249,9 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG "amp" %token T_BAD_CHARACTER "invalid character" +/* Generic type parameter bracket */ +%token T_GENERIC_LT "'<' (generic)" + /* Token used to force a parse error from the lexer */ %token T_ERROR @@ -288,6 +292,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type function_name non_empty_member_modifiers %type property_hook property_hook_list optional_property_hook_list hooked_property property_hook_body %type optional_parameter_list clone_argument_list non_empty_clone_argument_list +%type optional_generic_params generic_param_list generic_param generic_type_arg_list %type returns_ref function fn is_reference is_variadic property_modifiers property_hook_modifiers %type method_modifiers class_const_modifiers member_modifier optional_cpp_modifiers @@ -585,10 +590,10 @@ function_name: ; function_declaration_statement: - function returns_ref function_name backup_doc_comment '(' parameter_list ')' return_type + function returns_ref function_name optional_generic_params backup_doc_comment '(' parameter_list ')' return_type backup_fn_flags '{' inner_statement_list '}' backup_fn_flags - { $$ = zend_ast_create_decl(ZEND_AST_FUNC_DECL, $2 | $13, $1, $4, - zend_ast_get_str($3), $6, NULL, $11, $8, NULL); CG(extra_fn_flags) = $9; } + { $$ = zend_ast_create_decl(ZEND_AST_FUNC_DECL, $2 | $14, $1, $5, + zend_ast_get_str($3), $7, NULL, $12, $9, NULL, $4); CG(extra_fn_flags) = $10; } ; is_reference: @@ -603,11 +608,11 @@ is_variadic: class_declaration_statement: class_modifiers T_CLASS { $$ = CG(zend_lineno); } - T_STRING extends_from implements_list backup_doc_comment '{' class_statement_list '}' - { $$ = zend_ast_create_decl(ZEND_AST_CLASS, $1, $3, $7, zend_ast_get_str($4), $5, $6, $9, NULL, NULL); } + T_STRING optional_generic_params extends_from implements_list backup_doc_comment '{' class_statement_list '}' + { $$ = zend_ast_create_decl(ZEND_AST_CLASS, $1, $3, $8, zend_ast_get_str($4), $6, $7, $10, NULL, NULL, $5); } | T_CLASS { $$ = CG(zend_lineno); } - T_STRING extends_from implements_list backup_doc_comment '{' class_statement_list '}' - { $$ = zend_ast_create_decl(ZEND_AST_CLASS, 0, $2, $6, zend_ast_get_str($3), $4, $5, $8, NULL, NULL); } + T_STRING optional_generic_params extends_from implements_list backup_doc_comment '{' class_statement_list '}' + { $$ = zend_ast_create_decl(ZEND_AST_CLASS, 0, $2, $7, zend_ast_get_str($3), $5, $6, $9, NULL, NULL, $4); } ; class_modifiers: @@ -636,20 +641,20 @@ class_modifier: trait_declaration_statement: T_TRAIT { $$ = CG(zend_lineno); } - T_STRING backup_doc_comment '{' class_statement_list '}' - { $$ = zend_ast_create_decl(ZEND_AST_CLASS, ZEND_ACC_TRAIT, $2, $4, zend_ast_get_str($3), NULL, NULL, $6, NULL, NULL); } + T_STRING optional_generic_params backup_doc_comment '{' class_statement_list '}' + { $$ = zend_ast_create_decl(ZEND_AST_CLASS, ZEND_ACC_TRAIT, $2, $5, zend_ast_get_str($3), NULL, NULL, $7, NULL, NULL, $4); } ; interface_declaration_statement: T_INTERFACE { $$ = CG(zend_lineno); } - T_STRING interface_extends_list backup_doc_comment '{' class_statement_list '}' - { $$ = zend_ast_create_decl(ZEND_AST_CLASS, ZEND_ACC_INTERFACE, $2, $5, zend_ast_get_str($3), NULL, $4, $7, NULL, NULL); } + T_STRING optional_generic_params interface_extends_list backup_doc_comment '{' class_statement_list '}' + { $$ = zend_ast_create_decl(ZEND_AST_CLASS, ZEND_ACC_INTERFACE, $2, $6, zend_ast_get_str($3), NULL, $5, $8, NULL, NULL, $4); } ; enum_declaration_statement: T_ENUM { $$ = CG(zend_lineno); } T_STRING enum_backing_type implements_list backup_doc_comment '{' class_statement_list '}' - { $$ = zend_ast_create_decl(ZEND_AST_CLASS, ZEND_ACC_ENUM|ZEND_ACC_FINAL, $2, $6, zend_ast_get_str($3), NULL, $5, $8, NULL, $4); } + { $$ = zend_ast_create_decl(ZEND_AST_CLASS, ZEND_ACC_ENUM|ZEND_ACC_FINAL, $2, $6, zend_ast_get_str($3), NULL, $5, $8, NULL, $4, NULL); } ; enum_backing_type: @@ -670,6 +675,8 @@ enum_case_expr: extends_from: %empty { $$ = NULL; } | T_EXTENDS class_name { $$ = $2; } + | T_EXTENDS class_name T_GENERIC_LT generic_type_arg_list '>' + { $$ = zend_ast_create(ZEND_AST_GENERIC_TYPE, $2, $4); } ; interface_extends_list: @@ -682,6 +689,66 @@ implements_list: | T_IMPLEMENTS class_name_list { $$ = $2; } ; +optional_generic_params: + %empty { $$ = NULL; } + | T_GENERIC_LT generic_param_list '>' + { $$ = $2; } +; + +generic_param_list: + generic_param + { $$ = zend_ast_create_list(1, ZEND_AST_GENERIC_PARAMS, $1); } + | generic_param_list ',' generic_param + { $$ = zend_ast_list_add($1, $3); } +; + +generic_param: + T_STRING + { $$ = zend_ast_create(ZEND_AST_GENERIC_PARAM, $1, NULL); $$->attr = 0; } + | T_STRING ':' name + { $$ = zend_ast_create(ZEND_AST_GENERIC_PARAM, $1, $3); $$->attr = 0; } + | T_STRING T_STRING + { + /* "in T" or "out T" — variance annotation */ + zend_string *kw = zend_ast_get_str($1); + if (zend_string_equals_literal_ci(kw, "out")) { + $$ = zend_ast_create(ZEND_AST_GENERIC_PARAM, $2, NULL); + $$->attr = ZEND_GENERIC_VARIANCE_COVARIANT; + } else if (zend_string_equals_literal_ci(kw, "in")) { + $$ = zend_ast_create(ZEND_AST_GENERIC_PARAM, $2, NULL); + $$->attr = ZEND_GENERIC_VARIANCE_CONTRAVARIANT; + } else { + zend_throw_exception(zend_ce_compile_error, "Expected 'in' or 'out' variance annotation", 0); + YYERROR; + } + /* Release the keyword string from AST node $1 (node itself is arena-allocated) */ + zend_string_release(kw); + } + | T_STRING T_STRING ':' name + { + /* "in T: Constraint" or "out T: Constraint" */ + zend_string *kw = zend_ast_get_str($1); + if (zend_string_equals_literal_ci(kw, "out")) { + $$ = zend_ast_create(ZEND_AST_GENERIC_PARAM, $2, $4); + $$->attr = ZEND_GENERIC_VARIANCE_COVARIANT; + } else if (zend_string_equals_literal_ci(kw, "in")) { + $$ = zend_ast_create(ZEND_AST_GENERIC_PARAM, $2, $4); + $$->attr = ZEND_GENERIC_VARIANCE_CONTRAVARIANT; + } else { + zend_throw_exception(zend_ce_compile_error, "Expected 'in' or 'out' variance annotation", 0); + YYERROR; + } + zend_string_release(kw); + } +; + +generic_type_arg_list: + type_expr + { $$ = zend_ast_create_list(1, ZEND_AST_GENERIC_ARGS, $1); } + | generic_type_arg_list ',' type_expr + { $$ = zend_ast_list_add($1, $3); } +; + foreach_variable: variable { $$ = $1; } | ampersand variable { $$ = zend_ast_create(ZEND_AST_REF, $2); } @@ -874,6 +941,8 @@ type_without_static: T_ARRAY { $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_ARRAY); } | T_CALLABLE { $$ = zend_ast_create_ex(ZEND_AST_TYPE, IS_CALLABLE); } | name { $$ = $1; } + | name T_GENERIC_LT generic_type_arg_list '>' + { $$ = zend_ast_create(ZEND_AST_GENERIC_TYPE, $1, $3); } ; union_type_without_static_element: @@ -996,10 +1065,10 @@ attributed_class_statement: | class_const_modifiers T_CONST type_expr class_const_list ';' { $$ = zend_ast_create(ZEND_AST_CLASS_CONST_GROUP, $4, NULL, $3); $$->attr = $1; } - | method_modifiers function returns_ref identifier backup_doc_comment '(' parameter_list ')' + | method_modifiers function returns_ref identifier optional_generic_params backup_doc_comment '(' parameter_list ')' return_type backup_fn_flags method_body backup_fn_flags - { $$ = zend_ast_create_decl(ZEND_AST_METHOD, $3 | $1 | $12, $2, $5, - zend_ast_get_str($4), $7, NULL, $11, $9, NULL); CG(extra_fn_flags) = $10; } + { $$ = zend_ast_create_decl(ZEND_AST_METHOD, $3 | $1 | $13, $2, $6, + zend_ast_get_str($4), $8, NULL, $12, $10, NULL, $5); CG(extra_fn_flags) = $11; } | enum_case { $$ = $1; } ; @@ -1012,7 +1081,13 @@ class_statement: class_name_list: class_name { $$ = zend_ast_create_list(1, ZEND_AST_NAME_LIST, $1); } + | class_name T_GENERIC_LT generic_type_arg_list '>' + { $$ = zend_ast_create_list(1, ZEND_AST_NAME_LIST, + zend_ast_create(ZEND_AST_GENERIC_TYPE, $1, $3)); } | class_name_list ',' class_name { $$ = zend_ast_list_add($1, $3); } + | class_name_list ',' class_name T_GENERIC_LT generic_type_arg_list '>' + { $$ = zend_ast_list_add($1, + zend_ast_create(ZEND_AST_GENERIC_TYPE, $3, $5)); } ; trait_adaptations: @@ -1165,7 +1240,7 @@ property_hook: optional_parameter_list backup_fn_flags property_hook_body backup_fn_flags { $$ = zend_ast_create_decl( ZEND_AST_PROPERTY_HOOK, $1 | $2 | $9, $5, $4, zend_ast_get_str($3), - $6, NULL, $8, NULL, NULL); + $6, NULL, $8, NULL, NULL, NULL); CG(extra_fn_flags) = $7; } ; @@ -1231,7 +1306,7 @@ anonymous_class: extends_from implements_list backup_doc_comment '{' class_statement_list '}' { zend_ast *decl = zend_ast_create_decl( ZEND_AST_CLASS, ZEND_ACC_ANON_CLASS | $1, $3, $7, NULL, - $5, $6, $9, NULL, NULL); + $5, $6, $9, NULL, NULL, NULL); $$ = zend_ast_create(ZEND_AST_NEW, decl, $4); } ; @@ -1239,6 +1314,9 @@ anonymous_class: new_dereferenceable: T_NEW class_name_reference argument_list { $$ = zend_ast_create(ZEND_AST_NEW, $2, $3); } + | T_NEW class_name T_GENERIC_LT generic_type_arg_list '>' argument_list + { $$ = zend_ast_create(ZEND_AST_NEW, + zend_ast_create(ZEND_AST_GENERIC_TYPE, $2, $4), $6); } | T_NEW anonymous_class { $$ = $2; } | T_NEW attributes anonymous_class @@ -1248,6 +1326,10 @@ new_dereferenceable: new_non_dereferenceable: T_NEW class_name_reference { $$ = zend_ast_create(ZEND_AST_NEW, $2, zend_ast_create_list(0, ZEND_AST_ARG_LIST)); } + | T_NEW class_name T_GENERIC_LT generic_type_arg_list '>' + { $$ = zend_ast_create(ZEND_AST_NEW, + zend_ast_create(ZEND_AST_GENERIC_TYPE, $2, $4), + zend_ast_create_list(0, ZEND_AST_ARG_LIST)); } ; expr: @@ -1350,6 +1432,9 @@ expr: { $$ = zend_ast_create_binary_op(ZEND_SPACESHIP, $1, $3); } | expr T_INSTANCEOF class_name_reference { $$ = zend_ast_create(ZEND_AST_INSTANCEOF, $1, $3); } + | expr T_INSTANCEOF class_name T_GENERIC_LT generic_type_arg_list '>' + { $$ = zend_ast_create(ZEND_AST_INSTANCEOF, $1, + zend_ast_create(ZEND_AST_GENERIC_TYPE, $3, $5)); } | '(' expr ')' { $$ = $2; if ($$->kind == ZEND_AST_CONDITIONAL) $$->attr = ZEND_PARENTHESIZED_CONDITIONAL; @@ -1395,16 +1480,16 @@ expr: inline_function: - function returns_ref backup_doc_comment '(' parameter_list ')' lexical_vars return_type + function returns_ref optional_generic_params backup_doc_comment '(' parameter_list ')' lexical_vars return_type backup_fn_flags '{' inner_statement_list '}' backup_fn_flags - { $$ = zend_ast_create_decl(ZEND_AST_CLOSURE, $2 | $13, $1, $3, + { $$ = zend_ast_create_decl(ZEND_AST_CLOSURE, $2 | $14, $1, $4, NULL, - $5, $7, $11, $8, NULL); CG(extra_fn_flags) = $9; } - | fn returns_ref backup_doc_comment '(' parameter_list ')' return_type + $6, $8, $12, $9, NULL, $3); CG(extra_fn_flags) = $10; } + | fn returns_ref optional_generic_params backup_doc_comment '(' parameter_list ')' return_type T_DOUBLE_ARROW backup_fn_flags backup_lex_pos expr backup_fn_flags - { $$ = zend_ast_create_decl(ZEND_AST_ARROW_FUNC, $2 | $12, $1, $3, - NULL, $5, NULL, $11, $7, NULL); - CG(extra_fn_flags) = $9; } + { $$ = zend_ast_create_decl(ZEND_AST_ARROW_FUNC, $2 | $13, $1, $4, + NULL, $6, NULL, $12, $8, NULL, $3); + CG(extra_fn_flags) = $10; } ; fn: @@ -1457,6 +1542,9 @@ function_call: } | class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list { $$ = zend_ast_create(ZEND_AST_STATIC_CALL, $1, $3, $4); } + | class_name T_GENERIC_LT generic_type_arg_list '>' T_PAAMAYIM_NEKUDOTAYIM member_name argument_list + { $$ = zend_ast_create(ZEND_AST_STATIC_CALL, + zend_ast_create(ZEND_AST_GENERIC_TYPE, $1, $3), $6, $7); } | variable_class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list { $$ = zend_ast_create(ZEND_AST_STATIC_CALL, $1, $3, $4); } | callable_expr { $$ = CG(zend_lineno); } argument_list { diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 1c985189fd3c0..5d3abba81b8f1 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -119,6 +119,130 @@ do { \ #define ZEND_IS_OCT(c) ((c)>='0' && (c)<='7') #define ZEND_IS_HEX(c) (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F')) +/* Check if '<' at the current position starts a generic type argument/parameter list. + * Scans ahead looking for a balanced <...> containing valid type patterns. */ +static bool zend_is_generic_lt(void) +{ + const unsigned char *p = SCNG(yy_cursor); /* points past the '<' */ + const unsigned char *limit = SCNG(yy_limit); + int depth = 1; + bool has_content = 0; + + while (p < limit && depth > 0) { + unsigned char c = *p; + + /* Skip whitespace */ + if (c == ' ' || c == '\t' || c == '\n' || c == '\r') { + p++; + continue; + } + + /* Skip comments */ + if (c == '/' && (p + 1) < limit) { + if (p[1] == '/') { + /* Single-line comment: skip to end of line */ + p += 2; + while (p < limit && *p != '\n' && *p != '\r') p++; + continue; + } + if (p[1] == '*') { + /* Multi-line comment */ + p += 2; + while (p < limit) { + if (*p == '*' && (p + 1) < limit && p[1] == '/') { + p += 2; + break; + } + p++; + } + continue; + } + } + + /* Label (type name) */ + if (IS_LABEL_START(c)) { + has_content = 1; + p++; + while (p < limit && (IS_LABEL_SUCCESSOR(*p) || *p == '\\')) { + p++; + } + continue; + } + + /* Comma between type arguments */ + if (c == ',') { + p++; + continue; + } + + /* Colon for constraint (T: Foo) */ + if (c == ':') { + p++; + continue; + } + + /* Nested generic: < */ + if (c == '<') { + depth++; + p++; + continue; + } + + /* Closing generic: > */ + if (c == '>') { + depth--; + if (depth == 0) { + p++; + /* Check what follows the closing '>'. + * Valid followers: ( ) $ , ; { } > identifier extends implements whitespace */ + while (p < limit && (*p == ' ' || *p == '\t' || *p == '\n' || *p == '\r')) { + p++; + } + if (p >= limit) { + return has_content; + } + c = *p; + /* Valid token after '>' in generic context */ + if (c == '(' || c == ')' || c == '$' || c == ',' || c == ';' + || c == '{' || c == '}' || c == '>' || c == ':' + || IS_LABEL_START(c) || c == '|' || c == '&' + || c == '?') { + return has_content; + } + return 0; + } + continue; + } + + /* '>>' (T_SR) — could close two generic levels */ + if (c == '>' && (p + 1) < limit && p[1] == '>') { + depth -= 2; + if (depth <= 0) { + return has_content && depth == 0; + } + p += 2; + continue; + } + + /* Union type '|' or intersection '&' in type args */ + if (c == '|' || c == '&') { + p++; + continue; + } + + /* Nullable type '?' */ + if (c == '?') { + p++; + continue; + } + + /* Anything else — not a generic bracket */ + return 0; + } + + return 0; +} + static void strip_underscores(char *str, size_t *len) { @@ -195,6 +319,8 @@ void startup_scanner(void) zend_stack_init(&SCNG(nest_location_stack), sizeof(zend_nest_location)); zend_ptr_stack_init(&SCNG(heredoc_label_stack)); SCNG(heredoc_scan_ahead) = 0; + SCNG(last_token) = 0; + SCNG(generic_depth) = 0; } static void heredoc_label_dtor(zend_heredoc_label *heredoc_label) { @@ -1379,7 +1505,7 @@ ONUM "0o"[0-7]+(_[0-7]+)* LABEL [a-zA-Z_\x80-\xff][a-zA-Z0-9_\x80-\xff]* WHITESPACE [ \n\r\t]+ TABS_AND_SPACES [ \t]* -TOKENS [;:,.|^&+-/*=%!~$<>?@] +TOKENS [;:,.|^&+-/*=%!~$">>" { + /* Inside generic angle brackets, split >> into two > tokens */ + if (SCNG(generic_depth) > 0) { + yyless(1); /* Push back the second '>' */ + SCNG(generic_depth)--; + RETURN_TOKEN('>'); + } RETURN_TOKEN(T_SR); } @@ -1966,6 +2098,27 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_ RETURN_TOKEN(yytext[0]); } +"<" { + /* Check if this '<' starts a generic type argument/parameter list */ + int prev = SCNG(last_token); + if ((prev == T_STRING || prev == T_NAME_QUALIFIED + || prev == T_NAME_FULLY_QUALIFIED || prev == T_NAME_RELATIVE + || prev == T_FUNCTION || prev == T_FN) + && zend_is_generic_lt()) { + SCNG(generic_depth)++; + RETURN_TOKEN(T_GENERIC_LT); + } + RETURN_TOKEN('<'); +} + +">" { + /* Track closing of generic angle brackets */ + if (SCNG(generic_depth) > 0) { + SCNG(generic_depth)--; + } + RETURN_TOKEN('>'); +} + {TOKENS} { RETURN_TOKEN(yytext[0]); } @@ -3195,11 +3348,13 @@ emit_token_with_val: ZEND_ASSERT(Z_TYPE_P(zendlval) != IS_UNDEF); elem->ast = zend_ast_create_zval_with_lineno(zendlval, start_line); } + SCNG(last_token) = token; emit_token: if (SCNG(on_event)) { SCNG(on_event)(ON_TOKEN, token, start_line, yytext, yyleng, SCNG(on_event_context)); } + SCNG(last_token) = token; return token; emit_token_with_ident: @@ -3209,6 +3364,7 @@ emit_token_with_ident: if (SCNG(on_event)) { SCNG(on_event)(ON_TOKEN, token, start_line, yytext, yyleng, SCNG(on_event_context)); } + SCNG(last_token) = token; return token; return_whitespace: diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index 45eac02949d15..96dccfaa17749 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -1089,7 +1089,7 @@ ZEND_API zval *zend_std_write_property(zend_object *zobj, zend_string *name, zva ZVAL_COPY_VALUE(&tmp, value); // Increase refcount to prevent object from being released in __toString() GC_ADDREF(zobj); - bool type_matched = zend_verify_property_type(prop_info, &tmp, property_uses_strict_types()); + bool type_matched = zend_verify_property_type_ex(prop_info, &tmp, property_uses_strict_types(), zobj); if (UNEXPECTED(GC_DELREF(zobj) == 0)) { zend_object_released_while_assigning_to_property_error(prop_info); zend_objects_store_del(zobj); diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c index 6f6a826389442..96de3a003175c 100644 --- a/Zend/zend_objects.c +++ b/Zend/zend_objects.c @@ -26,6 +26,7 @@ #include "zend_exceptions.h" #include "zend_weakrefs.h" #include "zend_lazy_objects.h" +#include "zend_generics.h" static zend_always_inline void _zend_object_std_init(zend_object *object, zend_class_entry *ce) { @@ -35,6 +36,7 @@ static zend_always_inline void _zend_object_std_init(zend_object *object, zend_c object->extra_flags = 0; object->handlers = ce->default_object_handlers; object->properties = NULL; + object->generic_args = NULL; zend_objects_store_put(object); if (UNEXPECTED(ce->ce_flags & ZEND_ACC_USE_GUARDS)) { zval *guard_value = object->properties_table + object->ce->default_properties_count; @@ -82,6 +84,11 @@ ZEND_API void zend_object_std_dtor(zend_object *object) zend_weakrefs_notify(object); } + if (object->generic_args) { + zend_generic_args_dtor(object->generic_args); + object->generic_args = NULL; + } + if (UNEXPECTED(zend_object_is_lazy(object))) { zend_lazy_object_del_info(object); } @@ -351,5 +358,10 @@ ZEND_API zend_object *zend_objects_clone_obj(zend_object *old_object) zend_objects_clone_members(new_object, old_object); + /* Preserve generic type arguments on the clone */ + if (old_object->generic_args) { + new_object->generic_args = zend_copy_generic_args(old_object->generic_args); + } + return new_object; } diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c index 24b480ad71e66..c6b5b5e208295 100644 --- a/Zend/zend_opcode.c +++ b/Zend/zend_opcode.c @@ -28,6 +28,7 @@ #include "zend_sort.h" #include "zend_constants.h" #include "zend_observer.h" +#include "zend_generics.h" #include "zend_vm.h" @@ -91,6 +92,7 @@ void init_op_array(zend_op_array *op_array, zend_function_type type, int initial op_array->num_dynamic_func_defs = 0; op_array->dynamic_func_defs = NULL; + op_array->generic_params_info = NULL; ZEND_MAP_PTR_INIT(op_array->run_time_cache, NULL); op_array->cache_size = zend_op_array_extension_handles * sizeof(void*); @@ -111,6 +113,14 @@ ZEND_API void destroy_zend_function(zend_function *function) } ZEND_API void zend_type_release(zend_type type, bool persistent) { + if (ZEND_TYPE_IS_GENERIC_PARAM(type)) { + zend_generic_type_ref_dtor(ZEND_TYPE_GENERIC_PARAM_REF(type)); + return; + } + if (ZEND_TYPE_IS_GENERIC_CLASS(type)) { + zend_generic_class_ref_dtor(ZEND_TYPE_GENERIC_CLASS_REF(type)); + return; + } if (ZEND_TYPE_HAS_LIST(type)) { zend_type *list_type; ZEND_TYPE_LIST_FOREACH_MUTABLE(ZEND_TYPE_LIST(type), list_type) { @@ -376,6 +386,29 @@ ZEND_API void destroy_zend_class(zval *zv) if (ce->num_traits > 0) { _destroy_zend_class_traits_info(ce); } + + if (ce->generic_params_info) { + zend_generic_params_info_dtor(ce->generic_params_info); + } + if (ce->bound_generic_args) { + zend_generic_args_dtor(ce->bound_generic_args); + } + if (ce->interface_bound_generic_args) { + zend_generic_args *gargs; + ZEND_HASH_MAP_FOREACH_PTR(ce->interface_bound_generic_args, gargs) { + zend_generic_args_dtor(gargs); + } ZEND_HASH_FOREACH_END(); + zend_hash_destroy(ce->interface_bound_generic_args); + FREE_HASHTABLE(ce->interface_bound_generic_args); + } + if (ce->trait_bound_generic_args) { + zend_generic_args *gargs; + ZEND_HASH_MAP_FOREACH_PTR(ce->trait_bound_generic_args, gargs) { + zend_generic_args_dtor(gargs); + } ZEND_HASH_FOREACH_END(); + zend_hash_destroy(ce->trait_bound_generic_args); + FREE_HASHTABLE(ce->trait_bound_generic_args); + } } if (ce->default_properties_table) { @@ -601,6 +634,32 @@ ZEND_API void destroy_op_array(zend_op_array *op_array) op++; } } + /* Free generic args stored as literals in ZEND_NEW and ZEND_INSTANCEOF opcodes */ + if (op_array->fn_flags & ZEND_ACC_DONE_PASS_TWO) { + zend_op *op = op_array->opcodes; + zend_op *end = op + op_array->last; + while (op < end) { + if (op->opcode == ZEND_NEW && op->op1_type == IS_CONST + && (op->op2.num & 0x80000000)) { + /* Generic args literal is at op1.constant + 2 */ + zval *generic_args_zv = RT_CONSTANT(op, op->op1) + 2; + if (Z_TYPE_P(generic_args_zv) == IS_PTR && Z_PTR_P(generic_args_zv) != NULL) { + zend_generic_args_dtor((zend_generic_args *) Z_PTR_P(generic_args_zv)); + ZVAL_NULL(generic_args_zv); + } + } + if (op->opcode == ZEND_INSTANCEOF && op->op2_type == IS_CONST + && (op->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + /* Generic args literal is at op2.constant + 2 */ + zval *generic_args_zv = RT_CONSTANT(op, op->op2) + 2; + if (Z_TYPE_P(generic_args_zv) == IS_LONG && Z_LVAL_P(generic_args_zv) != 0) { + zend_generic_args_dtor((zend_generic_args *)(uintptr_t) Z_LVAL_P(generic_args_zv)); + ZVAL_LONG(generic_args_zv, 0); + } + } + op++; + } + } if (op_array->literals) { zval *literal = op_array->literals; zval *end = literal + op_array->last_literal; @@ -661,6 +720,10 @@ ZEND_API void destroy_op_array(zend_op_array *op_array) } efree(op_array->dynamic_func_defs); } + if (op_array->generic_params_info) { + zend_generic_params_info_dtor(op_array->generic_params_info); + op_array->generic_params_info = NULL; + } } static void zend_update_extended_stmts(zend_op_array *op_array) diff --git a/Zend/zend_types.h b/Zend/zend_types.h index 22dbfa9be879b..13f55fce0e8ff 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -89,6 +89,10 @@ typedef struct _zend_reference zend_reference; typedef struct _zend_ast_ref zend_ast_ref; typedef struct _zend_ast zend_ast; +typedef struct _zend_generic_type_ref zend_generic_type_ref; +typedef struct _zend_generic_class_ref zend_generic_class_ref; +typedef struct _zend_generic_args zend_generic_args; + typedef int (*compare_func_t)(const void *, const void *); typedef void (*swap_func_t)(void *, void *); typedef void (*sort_func_t)(void *, size_t, size_t, compare_func_t, swap_func_t); @@ -151,6 +155,14 @@ typedef struct { /* Must have same value as MAY_BE_NULL */ #define _ZEND_TYPE_NULLABLE_BIT 0x2u +/* Generic type parameter reference: ptr is a zend_generic_type_ref*. + * Uses bit 13 which is free in zend_type (IS_ITERABLE uses _ZEND_TYPE_ITERABLE_BIT instead). */ +#define MAY_BE_GENERIC_PARAM (1u << 13) + +/* Generic class reference (e.g., Collection): ptr is a zend_generic_class_ref*. + * Uses bit 11 which is free in zend_type (IS_CONSTANT_AST is an internal type, not used in hints). */ +#define _ZEND_TYPE_GENERIC_CLASS_BIT (1u << 11) + #define ZEND_TYPE_IS_SET(t) \ (((t).type_mask & _ZEND_TYPE_MASK) != 0) @@ -180,6 +192,23 @@ typedef struct { #define ZEND_TYPE_USES_ARENA(t) \ ((((t).type_mask) & _ZEND_TYPE_ARENA_BIT) != 0) +/* Generic type parameter reference (e.g., T in a method signature) */ +#define ZEND_TYPE_IS_GENERIC_PARAM(t) \ + (((t).type_mask & MAY_BE_GENERIC_PARAM) != 0) +#define ZEND_TYPE_GENERIC_PARAM_REF(t) \ + ((zend_generic_type_ref *)(t).ptr) +#define ZEND_TYPE_INIT_GENERIC_PARAM(ref, extra_flags) \ + _ZEND_TYPE_PREFIX { (void *)(ref), MAY_BE_GENERIC_PARAM | (extra_flags) } + +/* Generic class reference (e.g., Collection in a type hint) */ +#define ZEND_TYPE_IS_GENERIC_CLASS(t) \ + (((t).type_mask & _ZEND_TYPE_GENERIC_CLASS_BIT) != 0) +#define ZEND_TYPE_GENERIC_CLASS_REF(t) \ + ((zend_generic_class_ref *)(t).ptr) +#define ZEND_TYPE_INIT_GENERIC_CLASS(ref, allow_null, extra_flags) \ + _ZEND_TYPE_PREFIX { (void *)(ref), _ZEND_TYPE_GENERIC_CLASS_BIT \ + | ((allow_null) ? _ZEND_TYPE_NULLABLE_BIT : 0) | (extra_flags) } + #define ZEND_TYPE_IS_ONLY_MASK(t) \ (ZEND_TYPE_IS_SET(t) && (t).ptr == NULL) @@ -569,6 +598,7 @@ struct _zend_object { zend_class_entry *ce; const zend_object_handlers *handlers; HashTable *properties; + struct _zend_generic_args *generic_args; /* Per-instance type arguments (NULL if non-generic) */ zval properties_table[1]; }; diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index 86708f8c97a29..1b030983ff995 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2525,7 +2525,7 @@ ZEND_VM_C_LABEL(assign_obj_simple): property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); ZEND_VM_C_GOTO(free_and_exit_assign_obj); } else { ZEND_VM_C_LABEL(fast_assign_obj): @@ -2660,7 +2660,7 @@ ZEND_VM_HANDLER(25, ZEND_ASSIGN_STATIC_PROP, ANY, ANY, CACHE_SLOT, SPEC(OP_DATA= value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R); if (ZEND_TYPE_IS_SET(prop_info->type)) { - value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); FREE_OP_DATA(); } else { value = zend_assign_to_variable_ex(prop, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES(), &garbage); @@ -5968,17 +5968,21 @@ ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, N zend_function *constructor; zend_class_entry *ce; zend_execute_data *call; + uint32_t cache_slot; + bool has_generic_args = false; SAVE_OPLINE(); if (OP1_TYPE == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); + cache_slot = opline->op2.num & 0x7FFFFFFF; + has_generic_args = (opline->op2.num & 0x80000000) != 0; + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - CACHE_PTR(opline->op2.num, ce); + CACHE_PTR(cache_slot, ce); } } else if (OP1_TYPE == IS_UNUSED) { ce = zend_fetch_class(NULL, opline->op1.num); @@ -5996,6 +6000,22 @@ ZEND_VM_HANDLER(68, ZEND_NEW, UNUSED|CLASS_FETCH|CONST|VAR, UNUSED|CACHE_SLOT, N HANDLE_EXCEPTION(); } + /* Bind generic type arguments to the newly created object */ + if (has_generic_args) { + /* Generic args literal is stored at op1.constant + 2 + * (after class name + lowercase class name) */ + zval *generic_args_zv = RT_CONSTANT(opline, opline->op1) + 2; + zend_generic_args *compiled_args = (zend_generic_args *) Z_PTR_P(generic_args_zv); + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(compiled_args); + /* Verify type arguments satisfy constraints (e.g., T: Countable) */ + if (ce->generic_params_info) { + zend_verify_generic_args(ce->generic_params_info, Z_OBJ_P(result)->generic_args); + } + } else if (ce->bound_generic_args) { + /* Inherit bound generic args from class (e.g., IntList extends Collection) */ + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(ce->bound_generic_args); + } + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next @@ -8081,13 +8101,14 @@ ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMP|CV, UNUSED|CLASS_FETCH|CONST|VAR, CACH ZEND_VM_C_LABEL(try_instanceof): if (Z_TYPE_P(expr) == IS_OBJECT) { zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; if (OP2_TYPE == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); + CACHE_PTR(cache_slot, ce); } } } else if (OP2_TYPE == IS_UNUSED) { @@ -8101,6 +8122,21 @@ ZEND_VM_C_LABEL(try_instanceof): ce = Z_CE_P(EX_VAR(opline->op2.var)); } result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && OP2_TYPE == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } } else if ((OP1_TYPE & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { expr = Z_REFVAL_P(expr); ZEND_VM_C_GOTO(try_instanceof); diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index cbfae90802cfa..c5cad1c8d8173 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -854,7 +854,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_STATI ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -882,7 +882,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_STAT ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_EX int type) { USE_OPLINE @@ -895,7 +895,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_ &prop_info, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, type == BP_VAR_W ? opline->extended_value : 0 OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { - ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS) || (type == BP_VAR_UNSET)); + ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS)); prop = &EG(uninitialized_zval); } else if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK) && (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) @@ -917,25 +917,25 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_STATIC_PROP_R_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_STATIC_PROP_W_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_STATIC_PROP_RW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { @@ -945,13 +945,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_STATIC_ } } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_STATIC_PROP_UNSET_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_STATIC_PROP_IS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); @@ -1001,7 +1001,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_STATIC value = RT_CONSTANT((opline+1), (opline+1)->op1); if (ZEND_TYPE_IS_SET(prop_info->type)) { - value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); } else { @@ -1039,7 +1039,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_STATIC value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); if (ZEND_TYPE_IS_SET(prop_info->type)) { - value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } else { value = zend_assign_to_variable_ex(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); @@ -1057,6 +1057,43 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_STATIC ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *prop, *value; + zend_property_info *prop_info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + if (UNEXPECTED(!prop)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (ZEND_TYPE_IS_SET(prop_info->type)) { + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } else { + value = zend_assign_to_variable_ex(prop, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + /* assign_static_prop has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -1077,7 +1114,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_STATIC value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); if (ZEND_TYPE_IS_SET(prop_info->type)) { - value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); } else { @@ -1642,7 +1679,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_D ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif @@ -1756,7 +1792,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_D ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif @@ -1869,7 +1904,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif zend_observer_fcall_end(call, EG(exception) ? NULL : ret); ZEND_VM_FCALL_INTERRUPT_CHECK(call); @@ -2001,7 +2035,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_D ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif @@ -2132,7 +2165,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_D ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif @@ -2260,7 +2292,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif zend_observer_fcall_end(call, EG(exception) ? NULL : ret); ZEND_VM_FCALL_INTERRUPT_CHECK(call); @@ -3106,10 +3137,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV zval *variable_ptr = EX_VAR(opline->op2.var); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); } else { - if (UNEXPECTED(Z_ISREF_P(value))) { - value = Z_REFVAL_P(value); - value_type = Z_TYPE_INFO_P(value); - } zval *res = EX_VAR(opline->op2.var); zend_refcounted *gc = Z_COUNTED_P(value); @@ -3251,7 +3278,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_TICKS_SPEC_HA { USE_OPLINE - if (++EG(ticks_count) >= opline->extended_value) { + if ((uint32_t)++EG(ticks_count) >= opline->extended_value) { EG(ticks_count) = 0; if (zend_ticks_function) { SAVE_OPLINE(); @@ -3365,7 +3392,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_HANDLE_EXCEPT } uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes; - uint32_t current_try_catch_offset = -1; + int i, current_try_catch_offset = -1; if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE) && throw_op->extended_value & ZEND_FREE_ON_RETURN) { @@ -3379,7 +3406,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_HANDLE_EXCEPT } /* Find the innermost try/catch/finally the exception was thrown in */ - for (uint32_t i = 0; i < EX(func)->op_array.last_try_catch; i++) { + for (i = 0; i < EX(func)->op_array.last_try_catch; i++) { zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i]; if (try_catch->try_op > throw_op_num) { /* further blocks will not be relevant... */ @@ -4219,27 +4246,27 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_R ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_DYNAMIC_CALL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; zend_execute_data *call; SAVE_OPLINE(); - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); try_function_name: - if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value); - } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) { call = zend_init_dynamic_call_object(Z_OBJ_P(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_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) { + } 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 { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { function_name = ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -4250,7 +4277,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_DYNAMIC_ call = NULL; } - if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (UNEXPECTED(EG(exception))) { if (call) { @@ -4907,8 +4934,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -4975,9 +5000,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ zend_observer_fcall_end(execute_data, return_value); if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); }; - - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -5103,8 +5125,10 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } } while (0); + zend_exception_save(); Z_TRY_ADDREF_P(value); zend_throw_exception_object(value); + zend_exception_restore(); HANDLE_EXCEPTION(); @@ -5118,6 +5142,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CATCH_SPEC_CO SAVE_OPLINE(); /* Check whether an exception has been thrown, if not, jump over code */ + zend_exception_restore(); if (EG(exception) == NULL) { ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); } @@ -6095,38 +6120,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_TYPE_ASSERT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - SAVE_OPLINE(); - - zval *value = get_zval_ptr_undef(opline->op2_type, opline->op2, BP_VAR_R); - - uint8_t actual_type = Z_TYPE_P(value); - uint8_t expected_type = opline->extended_value & 0xff; - /* Simple types can be checked directly. */ - if (UNEXPECTED(actual_type != expected_type)) { - zend_function *fbc; - { - zval *fname = (zval*)RT_CONSTANT(opline, opline->op1); - ZEND_ASSERT(Z_EXTRA_P(fname) != 0); - fbc = Z_FUNC(EG(function_table)->arData[Z_EXTRA_P(fname)].val); - ZEND_ASSERT(fbc->type != ZEND_USER_FUNCTION); - } - uint16_t argno = opline->extended_value >> 16; - zend_arg_info *arginfo = &fbc->common.arg_info[argno - 1]; - - if (!zend_check_type(&arginfo->type, value, /* is_return_type */ false, /* is_internal */ true)) { - const char *param_name = get_function_arg_name(fbc, argno); - zend_string *expected = zend_type_to_string(arginfo->type); - zend_type_error("%s(): Argument #%d%s%s%s must be of type %s, %s given", ZSTR_VAL(fbc->common.function_name), argno, param_name ? " ($" : "", param_name ? param_name : "", param_name ? ")" : "", ZSTR_VAL(expected), zend_zval_value_name(value)); - zend_string_release(expected); - } - } - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -6778,17 +6771,13 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } dim = RT_CONSTANT(opline, opline->op2); if (IS_CONST != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CONST == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -6819,8 +6808,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC); @@ -6844,12 +6831,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ if (IS_CONST == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CONST & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -6862,15 +6843,11 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CONST & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -7038,8 +7015,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -7168,12 +7143,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CONST == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -9393,14 +9362,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_F ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); div_function(EX_VAR(opline->result.var), op1, op2); @@ -9408,14 +9377,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_CONS ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); pow_function(EX_VAR(opline->result.var), op1, op2); @@ -9423,23 +9392,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_CONS ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); @@ -9447,13 +9416,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV && @@ -9467,7 +9436,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -9479,7 +9448,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } @@ -9490,7 +9459,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { op1 = ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { op2 = ZVAL_UNDEFINED_OP2(); } concat_function(EX_VAR(opline->result.var), op1, op2); @@ -9501,14 +9470,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); compare_function(EX_VAR(opline->result.var), op1, op2); @@ -9516,24 +9485,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *dim, *value; SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_CONST != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_TMP_VAR, BP_VAR_R EXECUTE_DATA_CC); + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CONST == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -9542,13 +9507,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S } } else { fetch_dim_r_slow: - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } } else { - zend_fetch_dimension_address_read_R(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -9556,23 +9521,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -9584,20 +9547,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CONST & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -9605,15 +9562,11 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CONST & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -9622,7 +9575,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_wrong_property_read(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); ZVAL_NULL(EX_VAR(opline->result.var)); goto fetch_obj_r_finish; } while (0); @@ -9634,7 +9587,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -9694,7 +9647,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -9727,9 +9680,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -9753,7 +9706,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } #endif - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -9772,7 +9725,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -9780,8 +9733,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -9792,7 +9743,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ break; } } - if (IS_TMP_VAR == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(EX_VAR(opline->result.var)); @@ -9806,7 +9757,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -9833,7 +9784,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -9866,9 +9817,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -9877,7 +9828,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -9896,7 +9847,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -9909,29 +9860,23 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CONST == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_LIST_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; @@ -9939,16 +9884,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); @@ -9956,13 +9901,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV && @@ -9973,7 +9918,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -9985,7 +9930,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } @@ -10003,12 +9948,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S } op1_str = zval_get_string_func(op1); } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { op2_str = Z_STR_P(op2); } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { op2_str = zend_string_copy(Z_STR_P(op2)); } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } op2_str = zval_get_string_func(op2); @@ -10016,7 +9961,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S do { if (IS_CONST != IS_CONST) { if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { GC_ADDREF(op2_str); } @@ -10026,7 +9971,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S break; } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CONST == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { @@ -10047,7 +9992,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S if (IS_CONST != IS_CONST) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_string_release_ex(op2_str, 0); } } while (0); @@ -10057,7 +10002,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -10072,19 +10017,19 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ object = RT_CONSTANT(opline, opline->op1); - if (IS_TMP_VAR != IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST && + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { @@ -10126,14 +10071,14 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { object = ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } HANDLE_EXCEPTION(); } } - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -10146,18 +10091,18 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ called_scope = obj->ce; - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { zend_object *orig_obj = obj; - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); @@ -10168,7 +10113,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(obj == orig_obj)) { CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); @@ -10184,7 +10129,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -10215,7 +10160,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -10235,7 +10180,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { CACHE_PTR(opline->result.num, ce); } } @@ -10250,24 +10195,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M } if (IS_CONST == IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { /* nothing to do */ } else if (IS_CONST != IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == ce)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_TMP_VAR != IS_UNUSED) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if (IS_TMP_VAR & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -10283,7 +10228,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name)); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { @@ -10292,7 +10237,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) { CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); @@ -10300,7 +10245,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } } else { @@ -10348,7 +10293,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USER_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -10360,7 +10305,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USER_CAL uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC; SAVE_OPLINE(); - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) { ZEND_ASSERT(!error); @@ -10368,7 +10313,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USER_CAL * invoke a user error handler and throw an exception. * For the CONST and CV case we reuse the same exception block below * to make sure we don't increase VM size too much. */ - if (!(IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { + if (!((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } @@ -10393,7 +10338,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USER_CAL } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if ((IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { if (call_info & ZEND_CALL_CLOSURE) { zend_object_release(ZEND_CLOSURE_OBJECT(func)); } else if (call_info & ZEND_CALL_RELEASE_THIS) { @@ -10420,7 +10365,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_USER_CAL ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *expr_ptr, new_expr; @@ -10461,15 +10406,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE } } - if (IS_TMP_VAR != IS_UNUSED) { - zval *offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_string *str; zend_ulong hval; add_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index; } @@ -10480,7 +10425,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE hval = Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto add_again; } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { @@ -10513,7 +10458,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -10531,7 +10476,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -10546,14 +10491,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SP if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { zend_hash_real_init_mixed(Z_ARRVAL_P(array)); } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { ZVAL_ARR(array, zend_new_array(0)); ZEND_VM_NEXT_OPCODE(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -10563,7 +10508,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { HashTable *ht; @@ -10575,17 +10520,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY isset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index_prop; } } - value = zend_hash_find_ex(ht, str, IS_TMP_VAR == IS_CONST); + value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { hval = Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { offset = Z_REFVAL_P(offset); goto isset_again; } else { @@ -10617,7 +10562,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY } } - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } if (!(opline->extended_value & ZEND_ISEMPTY)) { @@ -10633,7 +10578,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -10643,7 +10588,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -10659,7 +10604,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -10671,9 +10616,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ result = (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -10684,7 +10629,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -10695,14 +10640,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXI SAVE_OPLINE(); key = RT_CONSTANT(opline, opline->op1); - subject = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { array_key_exists_array: ht = Z_ARRVAL_P(subject); result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { subject = Z_REFVAL_P(subject); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { goto array_key_exists_array; @@ -10718,7 +10663,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXI ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -10805,9 +10750,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CO } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -10976,7 +10921,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_IS_SPEC ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_CONST_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 @@ -10992,12 +10937,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_UNUSED == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CONST & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -11319,17 +11258,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NEW_SPEC_CONS zend_function *constructor; zend_class_entry *ce; zend_execute_data *call; + uint32_t cache_slot; + bool has_generic_args = false; SAVE_OPLINE(); if (IS_CONST == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); + cache_slot = opline->op2.num & 0x7FFFFFFF; + has_generic_args = (opline->op2.num & 0x80000000) != 0; + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - CACHE_PTR(opline->op2.num, ce); + CACHE_PTR(cache_slot, ce); } } else if (IS_CONST == IS_UNUSED) { ce = zend_fetch_class(NULL, opline->op1.num); @@ -11347,6 +11290,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NEW_SPEC_CONS HANDLE_EXCEPTION(); } + /* Bind generic type arguments to the newly created object */ + if (has_generic_args) { + /* Generic args literal is stored at op1.constant + 2 + * (after class name + lowercase class name) */ + zval *generic_args_zv = RT_CONSTANT(opline, opline->op1) + 2; + zend_generic_args *compiled_args = (zend_generic_args *) Z_PTR_P(generic_args_zv); + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(compiled_args); + /* Verify type arguments satisfy constraints (e.g., T: Countable) */ + if (ce->generic_params_info) { + zend_verify_generic_args(ce->generic_params_info, Z_OBJ_P(result)->generic_args); + } + } else if (ce->bound_generic_args) { + /* Inherit bound generic args from class (e.g., IntList extends Collection) */ + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(ce->bound_generic_args); + } + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next @@ -11554,7 +11513,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_VAR_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -11599,7 +11558,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY ZEND_VM_SMART_BRANCH(result, true); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -12119,17 +12078,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } dim = EX_VAR(opline->op2.var); if (IS_CONST != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CONST == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -12160,8 +12115,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC); @@ -12185,12 +12138,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_CV == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CONST & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -12203,15 +12150,11 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CONST & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -12379,8 +12322,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -12509,12 +12450,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CONST == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -15513,14 +15448,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_I ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -15549,6 +15484,200 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_LIST_R_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + /* The result and op1 can be the same cv zval */ + const uint32_t orig_val_type = Z_TYPE_INFO_P(val); + ZVAL_TRUE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + } else { + SAVE_OPLINE(); + ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *z; + + SAVE_OPLINE(); + z = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_P(z) == IS_STRING) { + zend_string *str = Z_STR_P(z); + + if (ZSTR_LEN(str) != 0) { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + } else { + zend_string *str = zval_get_string_func(z); + + if (ZSTR_LEN(str) != 0) { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_string_release_ex(str, 0); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + uint8_t op1_type; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZEND_VM_NEXT_OPCODE(); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + SAVE_OPLINE(); + op1_type = (IS_TMP_VAR|IS_VAR); + if (i_zend_is_true(val)) { + opline++; + } else { + opline = OP_JMP_ADDR(opline, opline->op2); + } + if (op1_type & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_nogc(val); + } + ZEND_VM_JMP(opline); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + uint8_t op1_type; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + } + ZEND_VM_NEXT_OPCODE(); + } + + SAVE_OPLINE(); + op1_type = (IS_TMP_VAR|IS_VAR); + if (i_zend_is_true(val)) { + opline = OP_JMP_ADDR(opline, opline->op2); + } else { + opline++; + } + if (op1_type & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_nogc(val); + } + ZEND_VM_JMP(opline); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + bool ret; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_NEXT_OPCODE(); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + SAVE_OPLINE(); + ret = i_zend_is_true(val); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (ret) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline++; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline = OP_JMP_ADDR(opline, opline->op2); + } + ZEND_VM_JMP(opline); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + bool ret; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + ZEND_VM_NEXT_OPCODE(); + } + } + + SAVE_OPLINE(); + ret = i_zend_is_true(val); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (ret) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline = OP_JMP_ADDR(opline, opline->op2); + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline++; + } + ZEND_VM_JMP(opline); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -15583,943 +15712,979 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_F ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container, *dim, *value; + zval *value; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - dim = RT_CONSTANT(opline, opline->op2); - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { -fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC); - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto fetch_dim_r_array; - } else { - goto fetch_dim_r_slow; + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + do { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) { + break; + } } - } else { -fetch_dim_r_slow: - if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } } - zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); + zend_throw_error(NULL, "Can only throw objects"); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } - } else { - zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC); - } - + } while (0); + zend_exception_save(); + Z_TRY_ADDREF_P(value); + zend_throw_exception_object(value); + zend_exception_restore(); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + HANDLE_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - - SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC); - + zval *val; - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + /* The result and op1 can be the same cv zval */ + const uint32_t orig_val_type = Z_TYPE_INFO_P(val); + ZVAL_FALSE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + } else { + SAVE_OPLINE(); + ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - void **cache_slot = NULL; + zval *obj; + zend_object *zobj; + zend_class_entry *ce, *scope; + zend_function *clone; + zend_object_clone_obj_t clone_call; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } + obj = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST || - ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - do { - if (((IS_TMP_VAR|IS_VAR) & IS_CV) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + /* ZEND_CLONE also exists as the clone() function and both implementations must be kept in sync. + * The OPcode intentionally does not support a clone-with property list to keep it simple. */ + + do { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) { + obj = Z_REFVAL_P(obj); + if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) { break; } } - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } } - zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2)); - ZVAL_NULL(EX_VAR(opline->result.var)); - goto fetch_obj_r_finish; - } while (0); - } - - /* here we are sure we are dealing with an object */ - do { - zend_object *zobj = Z_OBJ_P(container); - zend_string *name, *tmp_name; - zval *retval; - - if (IS_CONST == IS_CONST) { - cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); - - if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { - uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zend_type_error("clone(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(obj)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } while (0); - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { -fetch_obj_r_simple: - retval = OBJ_PROP(zobj, prop_offset); - if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) { - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { -fetch_obj_r_fast_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - ZEND_VM_NEXT_OPCODE(); - } - } - } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { - zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); - if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { - prop_offset = prop_info->offset; - goto fetch_obj_r_simple; - } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) { - zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET]; - ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION); - ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array)); + zobj = Z_OBJ_P(obj); + ce = zobj->ce; + clone = ce->clone; + clone_call = zobj->handlers->clone_obj; + if (UNEXPECTED(clone_call == NULL)) { + zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if ((IS_TMP_VAR|IS_VAR) & IS_CV) { - GC_ADDREF(zobj); - } - if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) { - call_info |= ZEND_CALL_RELEASE_THIS; - } - zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj); - call->prev_execute_data = execute_data; - call->call = NULL; - call->return_value = EX_VAR(opline->result.var); - call->run_time_cache = RUN_TIME_CACHE(&hook->op_array); + if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) { + scope = EX(func)->op_array.scope; + ZEND_ASSERT(!(clone->common.fn_flags & ZEND_ACC_PUBLIC)); + if (!zend_check_method_accessible(clone, scope)) { + zend_bad_method_call(clone, clone->common.function_name, scope); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } - execute_data = call; - EG(current_execute_data) = execute_data; - zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); + ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj)); -#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; -#else - EX(opline) = hook->op_array.opcodes; -#endif - LOAD_OPLINE_EX(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_op_array *new_op_array; + zval *inc_filename; + SAVE_OPLINE(); + inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } + UNDEF_RESULT(); + 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 (UNEXPECTED(new_op_array == NULL)) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } + } else if (new_op_array->last == 1 + && new_op_array->opcodes[0].opcode == ZEND_RETURN + && new_op_array->opcodes[0].op1_type == IS_CONST + && EXPECTED(zend_execute_ex == execute_ex)) { + if (RETURN_VALUE_USED(opline)) { + const zend_op *op = new_op_array->opcodes; + ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); + } + zend_destroy_static_vars(new_op_array); + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } else { + zval *return_value = NULL; + zend_execute_data *call; + if (RETURN_VALUE_USED(opline)) { + return_value = EX_VAR(opline->result.var); + } - ZEND_VM_ENTER_EX(); - } - /* Fall through to read_property for hooks. */ - } else if (EXPECTED(zobj->properties != NULL)) { - ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { - uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + new_op_array->scope = EX(func)->op_array.scope; - if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { - Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + call = zend_vm_stack_push_call_frame( + (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, + (zend_function*)new_op_array, 0, + Z_PTR(EX(This))); - if (EXPECTED(p->key == name) || - (EXPECTED(p->h == ZSTR_H(name)) && - EXPECTED(p->key != NULL) && - EXPECTED(zend_string_equal_content(p->key, name)))) { - retval = &p->val; - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { - goto fetch_obj_r_fast_copy; - } - } - } - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); - } - retval = zend_hash_find_known_hash(zobj->properties, name); - if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { - goto fetch_obj_r_fast_copy; - } - } - } - } - name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { + call->symbol_table = EX(symbol_table); } else { - name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); - if (UNEXPECTED(!name)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - break; - } + call->symbol_table = zend_rebuild_symbol_table(); } -#if ZEND_DEBUG - /* For non-standard object handlers, verify a declared property type in debug builds. - * Fetch prop_info before calling read_property(), as it may deallocate the object. */ - zend_property_info *prop_info = NULL; - if (zobj->handlers->read_property != zend_std_read_property) { - prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true); - } -#endif - retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var)); -#if ZEND_DEBUG - if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO - && ZEND_TYPE_IS_SET(prop_info->type)) { - ZVAL_OPT_DEREF(retval); - zend_verify_property_type(prop_info, retval, /* strict */ true); - } -#endif + call->prev_execute_data = execute_data; + i_init_code_execute_data(call, new_op_array, return_value); - if (IS_CONST != IS_CONST) { - zend_tmp_string_release(tmp_name); - } - if (retval != EX_VAR(opline->result.var)) { -fetch_obj_r_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - } else if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_unwrap_reference(retval); + if (EXPECTED(zend_execute_ex == execute_ex)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_ENTER(); + } else { + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + zend_vm_stack_free_call_frame(call); } - } while (0); - -fetch_obj_r_finish: - + zend_destroy_static_vars(new_op_array); + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - void **cache_slot = NULL; + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + zval *val; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST || - ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - do { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - break; - } - } - if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { - ZVAL_UNDEFINED_OP2(); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - goto fetch_obj_is_finish; - } while (0); + if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) { + zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator"); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); } - /* here we are sure we are dealing with an object */ - do { - zend_object *zobj = Z_OBJ_P(container); - zend_string *name, *tmp_name; - zval *retval; - - if (IS_CONST == IS_CONST) { - cache_slot = CACHE_ADDR(opline->extended_value); - - if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { - uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { -fetch_obj_is_simple: - retval = OBJ_PROP(zobj, prop_offset); - if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) { - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { -fetch_obj_is_fast_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - ZEND_VM_NEXT_OPCODE(); - } - } - } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { - if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { - zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); - prop_offset = prop_info->offset; - goto fetch_obj_is_simple; - } - /* Fall through to read_property for hooks. */ - } else if (EXPECTED(zobj->properties != NULL)) { - ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { - uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); +yield_from_try_again: + if (Z_TYPE_P(val) == IS_ARRAY) { + ZVAL_COPY_VALUE(&generator->values, val); + if (Z_OPT_REFCOUNTED_P(val)) { + Z_ADDREF_P(val); + } + Z_FE_POS(generator->values) = 0; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) { + zend_class_entry *ce = Z_OBJCE_P(val); + if (ce == zend_ce_generator) { + zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val); - if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { - Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + Z_ADDREF_P(val); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (EXPECTED(p->key == name) || - (EXPECTED(p->h == ZSTR_H(name)) && - EXPECTED(p->key != NULL) && - EXPECTED(zend_string_equal_content(p->key, name)))) { - retval = &p->val; - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { - goto fetch_obj_is_fast_copy; - } - } - } - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); - } - retval = zend_hash_find_known_hash(zobj->properties, name); - if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { - goto fetch_obj_is_fast_copy; - } - } + if (UNEXPECTED(new_gen->execute_data == NULL)) { + zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue"); + zval_ptr_dtor(val); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } else if (Z_ISUNDEF(new_gen->retval)) { + if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) { + zend_throw_error(NULL, "Impossible to yield from the Generator being currently run"); + zval_ptr_dtor(val); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } else { + zend_generator_yield_from(generator, new_gen); + } + } else { + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); } + ZEND_VM_NEXT_OPCODE(); } - name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); } else { - name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); - if (UNEXPECTED(!name)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - break; + zend_object_iterator *iter = ce->get_iterator(ce, val, 0); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) { + if (!EG(exception)) { + zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); + } + UNDEF_RESULT(); + HANDLE_EXCEPTION(); } - } - retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); + iter->index = 0; + if (iter->funcs->rewind) { + iter->funcs->rewind(iter); + if (UNEXPECTED(EG(exception) != NULL)) { + OBJ_RELEASE(&iter->std); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + } - if (IS_CONST != IS_CONST) { - zend_tmp_string_release(tmp_name); + ZVAL_OBJ(&generator->values, &iter->std); } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) { + val = Z_REFVAL_P(val); + goto yield_from_try_again; + } else { + zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables"); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } - if (retval != EX_VAR(opline->result.var)) { -fetch_obj_is_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - } else if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_unwrap_reference(retval); - } - } while (0); + /* This is the default return value + * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ + if (RETURN_VALUE_USED(opline)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } -fetch_obj_is_finish: + /* This generator has no send target (though the generator we delegate to might have one) */ + generator->send_target = NULL; + /* The GOTO VM uses a local opline variable. We need to set the opline + * variable in execute_data so we don't resume at an old position. */ + SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_RETURN(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value, *arg; + zval *value; - if (IS_CONST == IS_CONST) { - SAVE_OPLINE(); - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - uint32_t arg_num; - arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!arg)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { + ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(value); } + ZEND_VM_NEXT_OPCODE(); } else { - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - } + bool strict; - value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - ZVAL_COPY_VALUE(arg, value); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) { + value = Z_REFVAL_P(value); + if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { + ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } + } + + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + value = ZVAL_UNDEFINED_OP1(); } + strict = EX_USES_STRICT_TYPES(); + do { + if (EXPECTED(!strict)) { + zend_string *str; + zval tmp; + + if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) { + zend_error(E_DEPRECATED, + "strlen(): Passing null to parameter #1 ($string) of type string is deprecated"); + ZVAL_LONG(EX_VAR(opline->result.var), 0); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + break; + } + + ZVAL_COPY(&tmp, value); + if (zend_parse_arg_str_weak(&tmp, &str, 1)) { + ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); + zval_ptr_dtor(&tmp); + break; + } + zval_ptr_dtor(&tmp); + } + if (!EG(exception)) { + zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value)); + } + ZVAL_UNDEF(EX_VAR(opline->result.var)); + } while (0); } - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container, *dim, *value; - zend_long offset; - HashTable *ht; + zval *value; + int result = 0; - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - dim = RT_CONSTANT(opline, opline->op2); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { -fetch_dim_r_index_array: - if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { - offset = Z_LVAL_P(dim); - } else { - SAVE_OPLINE(); - zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - ZEND_VM_NEXT_OPCODE(); + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { +type_check_resource: + if (opline->extended_value != MAY_BE_RESOURCE + || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { + result = 1; } - } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto fetch_dim_r_index_array; - } else { - goto fetch_dim_r_index_slow; + } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { + goto type_check_resource; } - } else { -fetch_dim_r_index_slow: + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + result = ((1 << IS_NULL) & opline->extended_value) != 0; SAVE_OPLINE(); - if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_SMART_BRANCH(result, 1); + } else { + ZEND_VM_SMART_BRANCH(result, 0); } - -fetch_dim_r_index_undef: - ZVAL_NULL(EX_VAR(opline->result.var)); - SAVE_OPLINE(); - zend_undefined_offset(offset); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + uint32_t fetch_type; + zend_class_entry *called_scope, *scope; USE_OPLINE - zval *container, *dim, *value; - zend_long offset; - HashTable *ht; - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - dim = EX_VAR(opline->op2.var); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { -fetch_dim_r_index_array: - if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { - offset = Z_LVAL_P(dim); - } else { - SAVE_OPLINE(); - zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - ZEND_VM_NEXT_OPCODE(); - } - } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto fetch_dim_r_index_array; - } else { - goto fetch_dim_r_index_slow; - } - } else { -fetch_dim_r_index_slow: + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { SAVE_OPLINE(); - if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + zval *op = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) { + ZVAL_DEREF(op); + if (Z_TYPE_P(op) != IS_OBJECT) { + zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } } - zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); + + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -fetch_dim_r_index_undef: - ZVAL_NULL(EX_VAR(opline->result.var)); - SAVE_OPLINE(); - zend_undefined_offset(offset); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container, *dim, *value; - - SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); + fetch_type = opline->op1.num; + scope = EX(func)->op_array.scope; + if (UNEXPECTED(scope == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot use \"%s\" in the global scope", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { -fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_TMP_VAR, BP_VAR_R EXECUTE_DATA_CC); - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto fetch_dim_r_array; - } else { - goto fetch_dim_r_slow; + + switch (fetch_type) { + case ZEND_FETCH_CLASS_SELF: + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); + break; + case ZEND_FETCH_CLASS_PARENT: + if (UNEXPECTED(scope->parent == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, + "Cannot use \"parent\" when current class scope has no parent"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - } else { -fetch_dim_r_slow: - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); + break; + case ZEND_FETCH_CLASS_STATIC: + if (Z_TYPE(EX(This)) == IS_OBJECT) { + called_scope = Z_OBJCE(EX(This)); + } else { + called_scope = Z_CE(EX(This)); } - zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); - } - } else { - zend_fetch_dimension_address_read_R(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; + zval *op1, *op2; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + div_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - void **cache_slot = NULL; + zval *op1, *op2; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST || - ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - do { - if (((IS_TMP_VAR|IS_VAR) & IS_CV) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - break; - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - zend_wrong_property_read(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); - ZVAL_NULL(EX_VAR(opline->result.var)); - goto fetch_obj_r_finish; - } while (0); - } - - /* here we are sure we are dealing with an object */ - do { - zend_object *zobj = Z_OBJ_P(container); - zend_string *name, *tmp_name; - zval *retval; - - if (IS_TMP_VAR == IS_CONST) { - cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); - - if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { - uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { -fetch_obj_r_simple: - retval = OBJ_PROP(zobj, prop_offset); - if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) { - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { -fetch_obj_r_fast_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - ZEND_VM_NEXT_OPCODE(); - } - } - } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { - zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); - if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { - prop_offset = prop_info->offset; - goto fetch_obj_r_simple; - } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) { - zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET]; - ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION); - ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array)); - - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if ((IS_TMP_VAR|IS_VAR) & IS_CV) { - GC_ADDREF(zobj); - } - if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) { - call_info |= ZEND_CALL_RELEASE_THIS; - } - zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj); - call->prev_execute_data = execute_data; - call->call = NULL; - call->return_value = EX_VAR(opline->result.var); - call->run_time_cache = RUN_TIME_CACHE(&hook->op_array); - - execute_data = call; - EG(current_execute_data) = execute_data; - zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + pow_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); -#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; -#else - EX(opline) = hook->op_array.opcodes; -#endif - LOAD_OPLINE_EX(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); - ZEND_VM_ENTER_EX(); - } - /* Fall through to read_property for hooks. */ - } else if (EXPECTED(zobj->properties != NULL)) { - ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); - if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { - uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { - Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); - if (EXPECTED(p->key == name) || - (EXPECTED(p->h == ZSTR_H(name)) && - EXPECTED(p->key != NULL) && - EXPECTED(zend_string_equal_content(p->key, name)))) { - retval = &p->val; - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { - goto fetch_obj_r_fast_copy; - } - } - } - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); - } - retval = zend_hash_find_known_hash(zobj->properties, name); - if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { - goto fetch_obj_r_fast_copy; - } - } - } + if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { + zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); + } + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); - if (UNEXPECTED(!name)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - break; + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } } + ZEND_VM_NEXT_OPCODE(); + } else { + SAVE_OPLINE(); -#if ZEND_DEBUG - /* For non-standard object handlers, verify a declared property type in debug builds. - * Fetch prop_info before calling read_property(), as it may deallocate the object. */ - zend_property_info *prop_info = NULL; - if (zobj->handlers->read_property != zend_std_read_property) { - prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true); - } -#endif - retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var)); -#if ZEND_DEBUG - if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO - && ZEND_TYPE_IS_SET(prop_info->type)) { - ZVAL_OPT_DEREF(retval); - zend_verify_property_type(prop_info, retval, /* strict */ true); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + op1 = ZVAL_UNDEFINED_OP1(); } -#endif - - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + op2 = ZVAL_UNDEFINED_OP2(); } + concat_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (retval != EX_VAR(opline->result.var)) { -fetch_obj_r_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - } else if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_unwrap_reference(retval); - } - } while (0); -fetch_obj_r_finish: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - void **cache_slot = NULL; - - SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ + zval *op1, *op2; + double d1, d2; - if ((IS_TMP_VAR|IS_VAR) == IS_CONST || - ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - do { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - break; - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); } - if (IS_TMP_VAR == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { - ZVAL_UNDEFINED_OP2(); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; } - ZVAL_NULL(EX_VAR(opline->result.var)); - goto fetch_obj_is_finish; - } while (0); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - /* here we are sure we are dealing with an object */ - do { - zend_object *zobj = Z_OBJ_P(container); - zend_string *name, *tmp_name; - zval *retval; - - if (IS_TMP_VAR == IS_CONST) { - cache_slot = CACHE_ADDR(opline->extended_value); - - if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { - uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { -fetch_obj_is_simple: - retval = OBJ_PROP(zobj, prop_offset); - if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) { - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { -fetch_obj_is_fast_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - ZEND_VM_NEXT_OPCODE(); - } - } - } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { - if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { - zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); - prop_offset = prop_info->offset; - goto fetch_obj_is_simple; - } - /* Fall through to read_property for hooks. */ - } else if (EXPECTED(zobj->properties != NULL)) { - ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); - if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { - uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); - - if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { - Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - if (EXPECTED(p->key == name) || - (EXPECTED(p->h == ZSTR_H(name)) && - EXPECTED(p->key != NULL) && - EXPECTED(zend_string_equal_content(p->key, name)))) { - retval = &p->val; - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { - goto fetch_obj_is_fast_copy; - } - } - } - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); - } - retval = zend_hash_find_known_hash(zobj->properties, name); - if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { - goto fetch_obj_is_fast_copy; - } - } - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); - } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); - if (UNEXPECTED(!name)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - break; + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; } } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; } - - if (retval != EX_VAR(opline->result.var)) { -fetch_obj_is_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - } else if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_unwrap_reference(retval); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; } - } while (0); - -fetch_obj_is_finish: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value, *arg; + zval *op1, *op2; + double d1, d2; - if (IS_UNUSED == IS_CONST) { - SAVE_OPLINE(); - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - uint32_t arg_num; - arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!arg)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; } - } else { - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - } - - value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - ZVAL_COPY_VALUE(arg, value); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } } } - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *varname; - zend_string *name, *tmp_name; - HashTable *target_symbol_table; + zval *op1, *op2; + double d1, d2; - SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - name = Z_STR_P(varname); - } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { - name = Z_STR_P(varname); - tmp_name = NULL; - } else { - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { - varname = ZVAL_UNDEFINED_OP1(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; } - name = zval_try_get_tmp_string(varname, &tmp_name); - if (UNEXPECTED(!name)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } } } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); - zend_hash_del_ind(target_symbol_table, name); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zend_tmp_string_release(tmp_name); - } + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + compare_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - zval *result = EX_VAR(opline->result.var); - ZVAL_COPY(result, value); - ZEND_VM_NEXT_OPCODE(); + zval *op1, *op2; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + boolean_xor_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *dim, *value; SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - dim = EX_VAR(opline->op2.var); + dim = RT_CONSTANT(opline, opline->op2); if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC); + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -16528,13 +16693,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S } } else { fetch_dim_r_slow: - if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } } else { - zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC); } @@ -16542,23 +16707,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -16566,15 +16729,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if ((IS_TMP_VAR|IS_VAR) == IS_CONST || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if (((IS_TMP_VAR|IS_VAR) & IS_CV) && Z_ISREF_P(container)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -16583,7 +16742,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2)); ZVAL_NULL(EX_VAR(opline->result.var)); goto fetch_obj_r_finish; } while (0); @@ -16595,7 +16754,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S zend_string *name, *tmp_name; zval *retval; - if (IS_CV == IS_CONST) { + if (IS_CONST == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -16655,7 +16814,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -16688,9 +16847,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S } } } - name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -16714,7 +16873,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S } #endif - if (IS_CV != IS_CONST) { + if (IS_CONST != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -16733,7 +16892,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -16741,8 +16900,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if ((IS_TMP_VAR|IS_VAR) == IS_CONST || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -16753,7 +16910,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ break; } } - if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(EX_VAR(opline->result.var)); @@ -16767,7 +16924,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ zend_string *name, *tmp_name; zval *retval; - if (IS_CV == IS_CONST) { + if (IS_CONST == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -16794,7 +16951,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -16827,9 +16984,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ } } } - name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -16838,7 +16995,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - if (IS_CV != IS_CONST) { + if (IS_CONST != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -16857,1461 +17014,1571 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val; - - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - /* The result and op1 can be the same cv zval */ - const uint32_t orig_val_type = Z_TYPE_INFO_P(val); - ZVAL_TRUE(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - } else { - SAVE_OPLINE(); - ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ZEND_VM_NEXT_OPCODE(); -} + zval *op1, *op2; + zend_string *op1_str, *op2_str, *str; -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *z; - SAVE_OPLINE(); - z = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - if (Z_TYPE_P(z) == IS_STRING) { - zend_string *str = Z_STR_P(z); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); - if (ZSTR_LEN(str) != 0) { - zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else { + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } } - } else { - zend_string *str = zval_get_string_func(z); + ZEND_VM_NEXT_OPCODE(); + } - if (ZSTR_LEN(str) != 0) { - zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) { + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + op1_str = Z_STR_P(op1); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + op1_str = zend_string_copy(Z_STR_P(op1)); + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_string_release_ex(str, 0); + op1_str = zval_get_string_func(op1); + } + if (IS_CONST == IS_CONST) { + op2_str = Z_STR_P(op2); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + op2_str = zend_string_copy(Z_STR_P(op2)); + } else { + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + } + op2_str = zval_get_string_func(op2); } + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { + GC_ADDREF(op2_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + zend_string_release_ex(op1_str, 0); + break; + } + } + if (IS_CONST != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { + GC_ADDREF(op1_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + zend_string_release_ex(op2_str, 0); + break; + } + } + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CONST != IS_CONST) { + zend_string_release_ex(op2_str, 0); + } + } while (0); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val; - uint8_t op1_type; + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + SAVE_OPLINE(); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZEND_VM_NEXT_OPCODE(); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CONST != IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + if (IS_CONST != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } } - } - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + zend_throw_error(NULL, "Method name must be a string"); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); } - SAVE_OPLINE(); - op1_type = IS_TMP_VAR; - if (i_zend_is_true(val)) { - opline++; + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + obj = Z_OBJ_P(object); } else { - opline = OP_JMP_ADDR(opline, opline->op2); - } - if (op1_type & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_nogc(val); - } - ZEND_VM_JMP(opline); -} + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + } else { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + zend_reference *ref = Z_REF_P(object); -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *val; - uint8_t op1_type; + object = &ref->val; + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else { + Z_ADDREF_P(object); + } + } + break; + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CONST != IS_CONST) { - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { + } + HANDLE_EXCEPTION(); + } + } + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + zend_invalid_method_call(object, function_name); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); HANDLE_EXCEPTION(); } - } - ZEND_VM_NEXT_OPCODE(); + } while (0); } - SAVE_OPLINE(); - op1_type = IS_TMP_VAR; - if (i_zend_is_true(val)) { - opline = OP_JMP_ADDR(opline, opline->op2); + called_scope = obj->ce; + + if (IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { - opline++; - } - if (op1_type & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_nogc(val); + zend_object *orig_obj = obj; + + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); + } + + + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); + } + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + GC_ADDREF(obj); /* For $this pointer */ + if (GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); + } + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } } - ZEND_VM_JMP(opline); -} -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *val; - bool ret; + if (IS_CONST != IS_CONST) { - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - ZEND_VM_NEXT_OPCODE(); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { + zend_objects_store_del(obj); if (UNEXPECTED(EG(exception))) { HANDLE_EXCEPTION(); } } - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; } - SAVE_OPLINE(); - ret = i_zend_is_true(val); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (ret) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - opline++; - } else { - ZVAL_FALSE(EX_VAR(opline->result.var)); - opline = OP_JMP_ADDR(opline, opline->op2); - } - ZEND_VM_JMP(opline); + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val; - bool ret; - - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + zval *value, *arg; - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - ZEND_VM_NEXT_OPCODE(); + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); } - SAVE_OPLINE(); - ret = i_zend_is_true(val); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (ret) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - opline = OP_JMP_ADDR(opline, opline->op2); - } else { - ZVAL_FALSE(EX_VAR(opline->result.var)); - opline++; + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } } - ZEND_VM_JMP(opline); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval_ptr; - zval *return_value; - - - retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - return_value = EX(return_value); - + zval *op1, *op2; + double d1, d2; - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +case_true: + ZEND_VM_SMART_BRANCH_TRUE(); + } else { +case_false: + ZEND_VM_SMART_BRANCH_FALSE(); } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto case_double; } - } else { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +case_double: + if (d1 == d2) { + goto case_true; + } else { + goto case_false; } - } else if (IS_TMP_VAR == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - SAVE_OPLINE(); - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto case_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } + + if (result) { + goto case_true; } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); + goto case_false; } } } - - - - - - - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval_ptr; - zval *return_value; - + zval *container; + bool result; + zend_ulong hval; + zval *offset; SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = RT_CONSTANT(opline, opline->op2); - return_value = EX(return_value); - - - do { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) || - (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { - /* Not supposed to happen, but we'll allow it */ - zend_error(E_NOTICE, "Only variable references should be returned by reference"); - - retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (!return_value) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } else { - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - break; - } + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + HashTable *ht; + zval *value; + zend_string *str; - ZVAL_NEW_REF(return_value, retval_ptr); - if (IS_TMP_VAR == IS_CONST) { - Z_TRY_ADDREF_P(retval_ptr); +isset_dim_obj_array: + ht = Z_ARRVAL_P(container); +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; } } - break; + value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + offset = Z_REFVAL_P(offset); + goto isset_again; + } else { + value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); + if (UNEXPECTED(EG(exception))) { + result = 0; + goto isset_dim_obj_exit; + } } - retval_ptr = zend_get_bad_ptr(); + if (!(opline->extended_value & ZEND_ISEMPTY)) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); - if (IS_TMP_VAR == IS_VAR) { - ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); - if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { - zend_error(E_NOTICE, "Only variable references should be returned by reference"); - if (return_value) { - ZVAL_NEW_REF(return_value, retval_ptr); - } else { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } - break; - } - } + if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { + /* avoid exception check */ - if (return_value) { - if (Z_ISREF_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } else { - ZVAL_MAKE_REF_EX(retval_ptr, 2); + + ZEND_VM_SMART_BRANCH(result, 0); } - ZVAL_REF(return_value, Z_REF_P(retval_ptr)); + } else { + result = (value == NULL || !i_zend_is_true(value)); } + goto isset_dim_obj_exit; + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto isset_dim_obj_array; + } + } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } while (0); - - + if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + offset++; + } + if (!(opline->extended_value & ZEND_ISEMPTY)) { + result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); + } else { + result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); + } +isset_dim_obj_exit: - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval; - - zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + zval *container; + int result; + zval *offset; + zend_string *name, *tmp_name; SAVE_OPLINE(); - retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = RT_CONSTANT(opline, opline->op2); - /* Copy return value into generator->retval */ - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(&generator->retval, retval); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { - Z_ADDREF(generator->retval); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } + } else { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } - } else if (IS_TMP_VAR == IS_CV) { - ZVAL_COPY_DEREF(&generator->retval, retval); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_refcounted *ref = Z_COUNTED_P(retval); + } - retval = Z_REFVAL_P(retval); - ZVAL_COPY_VALUE(&generator->retval, retval); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval)) { - Z_ADDREF_P(retval); - } - } else { - ZVAL_COPY_VALUE(&generator->retval, retval); + if (IS_CONST == IS_CONST) { + name = Z_STR_P(offset); + } else { + name = zval_try_get_tmp_string(offset, &tmp_name); + if (UNEXPECTED(!name)) { + result = 0; + goto isset_object_finish; } } + result = + (opline->extended_value & ZEND_ISEMPTY) ^ + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - EG(current_execute_data) = EX(prev_execute_data); + if (IS_CONST != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - /* Close the generator to free up resources */ - zend_generator_close(generator, 1); +isset_object_finish: - /* Pass execution back to handling code */ - ZEND_VM_RETURN(); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; + + zval *key, *subject; + HashTable *ht; + bool result; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - do { - if (IS_TMP_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) { - break; - } - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } + key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + subject = RT_CONSTANT(opline, opline->op2); + + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { +array_key_exists_array: + ht = Z_ARRVAL_P(subject); + result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); + } else { + if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + subject = Z_REFVAL_P(subject); + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { + goto array_key_exists_array; } - zend_throw_error(NULL, "Can only throw objects"); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); } - } while (0); + zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); + result = 0; + } + - Z_TRY_ADDREF_P(value); - zend_throw_exception_object(value); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *arg, *param; + zval *expr; + bool result; SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); +try_instanceof: + if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; + + if (IS_CONST == IS_CONST) { + ce = CACHED_PTR(cache_slot); + if (UNEXPECTED(ce == NULL)) { + ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); + if (EXPECTED(ce)) { + CACHE_PTR(cache_slot, ce); + } + } + } else if (IS_CONST == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op2.var)); + } + result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_CONST == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { + expr = Z_REFVAL_P(expr); + goto try_instanceof; } else { - ZVAL_COPY(param, arg); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + result = 0; } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val; + zval *container, *dim, *value; + zend_long offset; + HashTable *ht; - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - /* The result and op1 can be the same cv zval */ - const uint32_t orig_val_type = Z_TYPE_INFO_P(val); - ZVAL_FALSE(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + dim = RT_CONSTANT(opline, opline->op2); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +fetch_dim_r_index_array: + if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { + offset = Z_LVAL_P(dim); + } else { SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); + zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ht = Z_ARRVAL_P(container); + ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + ZEND_VM_NEXT_OPCODE(); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto fetch_dim_r_index_array; + } else { + goto fetch_dim_r_index_slow; } } else { +fetch_dim_r_index_slow: SAVE_OPLINE(); - ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val)); + if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - ZEND_VM_NEXT_OPCODE(); + +fetch_dim_r_index_undef: + ZVAL_NULL(EX_VAR(opline->result.var)); + SAVE_OPLINE(); + zend_undefined_offset(offset); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *obj; - zend_object *zobj; - zend_class_entry *ce, *scope; - zend_function *clone; - zend_object_clone_obj_t clone_call; - - SAVE_OPLINE(); - obj = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - /* ZEND_CLONE also exists as the clone() function and both implementations must be kept in sync. - * The OPcode intentionally does not support a clone-with property list to keep it simple. */ + zval *container, *dim, *value; + zend_long offset; + HashTable *ht; - do { - if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) { - obj = Z_REFVAL_P(obj); - if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) { - break; - } - } - ZVAL_UNDEF(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_type_error("clone(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(obj)); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + dim = EX_VAR(opline->op2.var); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +fetch_dim_r_index_array: + if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { + offset = Z_LVAL_P(dim); + } else { + SAVE_OPLINE(); + zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - } while (0); - - zobj = Z_OBJ_P(obj); - ce = zobj->ce; - clone = ce->clone; - clone_call = zobj->handlers->clone_obj; - if (UNEXPECTED(clone_call == NULL)) { - zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - - if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) { - scope = EX(func)->op_array.scope; - ZEND_ASSERT(!(clone->common.fn_flags & ZEND_ACC_PUBLIC)); - if (!zend_check_method_accessible(clone, scope)) { - zend_bad_method_call(clone, clone->common.function_name, scope); + ht = Z_ARRVAL_P(container); + ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + ZEND_VM_NEXT_OPCODE(); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto fetch_dim_r_index_array; + } else { + goto fetch_dim_r_index_slow; + } + } else { +fetch_dim_r_index_slow: + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; } + zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj)); - +fetch_dim_r_index_undef: + ZVAL_NULL(EX_VAR(opline->result.var)); + SAVE_OPLINE(); + zend_undefined_offset(offset); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *expr; - zval *result = EX_VAR(opline->result.var); + zval *op1, *op2; SAVE_OPLINE(); - expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - switch (opline->extended_value) { - case IS_LONG: - ZVAL_LONG(result, zval_get_long(expr)); - break; - case IS_DOUBLE: - ZVAL_DOUBLE(result, zval_get_double(expr)); - break; - case IS_STRING: - ZVAL_STR(result, zval_get_string(expr)); - break; - default: - ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead"); - if (IS_TMP_VAR & (IS_VAR|IS_CV)) { - ZVAL_DEREF(expr); - } - /* If value is already of correct type, return it directly */ - if (Z_TYPE_P(expr) == opline->extended_value) { - ZVAL_COPY_VALUE(result, expr); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); - } else if (IS_TMP_VAR != IS_TMP_VAR) { - if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - if (opline->extended_value == IS_ARRAY) { - zend_cast_zval_to_array(result, expr, IS_TMP_VAR); - } else { - ZEND_ASSERT(opline->extended_value == IS_OBJECT); - zend_cast_zval_to_object(result, expr, IS_TMP_VAR); - } - } - + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + div_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_op_array *new_op_array; - zval *inc_filename; + zval *op1, *op2; SAVE_OPLINE(); - inc_filename = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - } - UNDEF_RESULT(); - 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 (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(opline)) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - } - } else if (new_op_array->last == 1 - && new_op_array->opcodes[0].opcode == ZEND_RETURN - && new_op_array->opcodes[0].op1_type == IS_CONST - && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(opline)) { - const zend_op *op = new_op_array->opcodes; - - ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); - } - zend_destroy_static_vars(new_op_array); - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - } else { - zval *return_value = NULL; - zend_execute_data *call; - if (RETURN_VALUE_USED(opline)) { - return_value = EX_VAR(opline->result.var); - } - - new_op_array->scope = EX(func)->op_array.scope; - - call = zend_vm_stack_push_call_frame( - (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, - (zend_function*)new_op_array, 0, - Z_PTR(EX(This))); - - 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); - - - if (EXPECTED(zend_execute_ex == execute_ex)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_ENTER(); - } else { - ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); - zend_execute_ex(call); - zend_vm_stack_free_call_frame(call); - } - - zend_destroy_static_vars(new_op_array); - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - if (UNEXPECTED(EG(exception) != NULL)) { - zend_rethrow_exception(execute_data); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + pow_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *array_ptr, *result; - - SAVE_OPLINE(); - - array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { - result = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(result, array_ptr); - if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { - Z_ADDREF_P(array_ptr); - } - Z_FE_POS_P(result) = 0; - + zval *op1, *op2; - ZEND_VM_NEXT_OPCODE(); - } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { - zend_object *zobj = Z_OBJ_P(array_ptr); - if (!zobj->ce->get_iterator) { - if (UNEXPECTED(zend_object_is_lazy(zobj))) { - zobj = zend_lazy_object_init(zobj); - if (UNEXPECTED(EG(exception))) { - UNDEF_RESULT(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - HANDLE_EXCEPTION(); - } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); } - HashTable *properties = zobj->properties; - if (properties) { - if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) { - if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) { - GC_DELREF(properties); - } - properties = zobj->properties = zend_array_dup(properties); - } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { - properties = zobj->handlers->get_properties(zobj); + ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - - result = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(result, array_ptr); - if (IS_TMP_VAR != IS_TMP_VAR) { - Z_ADDREF_P(array_ptr); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); - if (zend_hash_num_elements(properties) == 0) { - Z_FE_ITER_P(result) = (uint32_t) -1; - - - ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { + zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); + } + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } - - Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } else { - bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } else if (is_empty) { - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); - } else { - ZEND_VM_NEXT_OPCODE(); + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } } + ZEND_VM_NEXT_OPCODE(); } else { - zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; + SAVE_OPLINE(); + + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + op1 = ZVAL_UNDEFINED_OP1(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + op2 = ZVAL_UNDEFINED_OP2(); + } + concat_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *array_ptr, *array_ref; - - SAVE_OPLINE(); + zval *op1, *op2; + double d1, d2; - if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - array_ref = array_ptr = zend_get_bad_ptr(); - if (Z_ISREF_P(array_ref)) { - array_ptr = Z_REFVAL_P(array_ref); - } - } else { - array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - } - - if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { - if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - if (array_ptr == array_ref) { - ZVAL_NEW_REF(array_ref, array_ref); - array_ptr = Z_REFVAL_P(array_ref); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); } - Z_ADDREF_P(array_ref); - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); - } else { - array_ref = EX_VAR(opline->result.var); - ZVAL_NEW_REF(array_ref, array_ptr); - array_ptr = Z_REFVAL_P(array_ref); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; } - if (IS_TMP_VAR == IS_CONST) { - ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr))); - } else { - SEPARATE_ARRAY(array_ptr); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; } - Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0); - - - ZEND_VM_NEXT_OPCODE(); - } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { - if (!Z_OBJCE_P(array_ptr)->get_iterator) { - zend_object *zobj = Z_OBJ_P(array_ptr); - HashTable *properties; - if (UNEXPECTED(zend_object_is_lazy(zobj))) { - zobj = zend_lazy_object_init(zobj); - if (UNEXPECTED(EG(exception))) { - UNDEF_RESULT(); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - HANDLE_EXCEPTION(); - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); } - if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - if (array_ptr == array_ref) { - ZVAL_NEW_REF(array_ref, array_ref); - array_ptr = Z_REFVAL_P(array_ref); - } - Z_ADDREF_P(array_ref); - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; } else { - array_ptr = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(array_ptr, array_ref); + goto is_equal_false; } - if (Z_OBJ_P(array_ptr)->properties - && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) { - if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) { - GC_DELREF(Z_OBJ_P(array_ptr)->properties); - } - Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); } - - properties = Z_OBJPROP_P(array_ptr); - if (zend_hash_num_elements(properties) == 0) { - Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1; - - - ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); } - - Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } else if (is_empty) { - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + if (result) { + goto is_equal_true; } else { - ZEND_VM_NEXT_OPCODE(); + goto is_equal_false; } } - } else { - zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_FETCH_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *array; - zval *value; - uint32_t value_type; - HashTable *fe_ht; - HashPosition pos; + zval *op1, *op2; + double d1, d2; - array = EX_VAR(opline->op1.var); - if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) { - ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - fe_ht = Z_ARRVAL_P(array); - pos = Z_FE_POS_P(array); - if (HT_IS_PACKED(fe_ht)) { - value = fe_ht->arPacked + pos; - while (1) { - if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { - /* reached end of iteration */ - ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); - ZEND_VM_CONTINUE(); - } - value_type = Z_TYPE_INFO_P(value); - ZEND_ASSERT(value_type != IS_INDIRECT); - if (EXPECTED(value_type != IS_UNDEF)) { - break; + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); } - pos++; - value++; + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; } - Z_FE_POS_P(array) = pos + 1; - if (RETURN_VALUE_USED(opline)) { - ZVAL_LONG(EX_VAR(opline->result.var), pos); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; } - } else { - Bucket *p; - - p = fe_ht->arData + pos; - while (1) { - if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { - /* reached end of iteration */ - ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); - ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); } - pos++; - value = &p->val; - value_type = Z_TYPE_INFO_P(value); - ZEND_ASSERT(value_type != IS_INDIRECT); - if (EXPECTED(value_type != IS_UNDEF)) { - break; + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); } - p++; - } - Z_FE_POS_P(array) = pos; - if (RETURN_VALUE_USED(opline)) { - if (!p->key) { - ZVAL_LONG(EX_VAR(opline->result.var), p->h); + if (result) { + goto is_equal_true; } else { - ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key); + goto is_equal_false; } } } - if (EXPECTED(opline->op2_type == IS_CV)) { - zval *variable_ptr = EX_VAR(opline->op2.var); - SAVE_OPLINE(); - zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - if (UNEXPECTED(Z_ISREF_P(value))) { - value = Z_REFVAL_P(value); - value_type = Z_TYPE_INFO_P(value); - } - zval *res = EX_VAR(opline->op2.var); - zend_refcounted *gc = Z_COUNTED_P(value); - - ZVAL_COPY_VALUE_EX(res, value, gc, value_type); - if (Z_TYPE_INFO_REFCOUNTED(value_type)) { - GC_ADDREF(gc); - } - ZEND_VM_NEXT_OPCODE(); - } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *op1, *op2; + double d1, d2; - if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting)) - && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) { - EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var)); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } } - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; - zend_reference *ref = NULL; - bool ret; - - SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + zval *op1, *op2; + double d1, d2; - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) { - if (IS_TMP_VAR == IS_VAR) { - ref = Z_REF_P(value); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } } - value = Z_REFVAL_P(value); - } - - ret = i_zend_is_true(value); - - if (UNEXPECTED(EG(exception))) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - if (ret) { - zval *result = EX_VAR(opline->result.var); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - ZVAL_COPY_VALUE(result, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); - } else if (IS_TMP_VAR == IS_CV) { - if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); - } else if (IS_TMP_VAR == IS_VAR && ref) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(result)) { - Z_ADDREF_P(result); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; } } - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + compare_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; - zend_reference *ref = NULL; + zval *op1, *op2; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + boolean_xor_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { - if (IS_TMP_VAR & IS_VAR) { - ref = Z_REF_P(value); - } - value = Z_REFVAL_P(value); - } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container, *dim, *value; - if (Z_TYPE_P(value) > IS_NULL) { - zval *result = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(result, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); - } else if (IS_TMP_VAR == IS_CV) { - if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); - } else if ((IS_TMP_VAR & IS_VAR) && ref) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(result)) { - Z_ADDREF_P(result); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +fetch_dim_r_array: + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC); + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto fetch_dim_r_array; + } else { + goto fetch_dim_r_slow; } + } else { +fetch_dim_r_slow: + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); - } - - if ((IS_TMP_VAR & IS_VAR) && ref) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } + } else { + zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val, *result; - - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + zval *container; - if (Z_TYPE_P(val) > IS_NULL) { + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + void **cache_slot = NULL; + + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) { - val = Z_REFVAL_P(val); - if (Z_TYPE_P(val) <= IS_NULL) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; } } - ZEND_VM_NEXT_OPCODE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + ZVAL_NULL(EX_VAR(opline->result.var)); + goto fetch_obj_r_finish; } while (0); } - result = EX_VAR(opline->result.var); - uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK; - if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { - ZVAL_NULL(result); - if (IS_TMP_VAR == IS_CV - && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF) - && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0 - ) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { - ZVAL_FALSE(result); - } else { - ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); - ZVAL_TRUE(result); - } + /* here we are sure we are dealing with an object */ + do { + zend_object *zobj = Z_OBJ_P(container); + zend_string *name, *tmp_name; + zval *retval; - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); -} + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - zval *result = EX_VAR(opline->result.var); + if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZVAL_NULL(result); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { +fetch_obj_r_simple: + retval = OBJ_PROP(zobj, prop_offset); + if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) { + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { +fetch_obj_r_fast_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); + } + } + } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { + zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { + prop_offset = prop_info->offset; + goto fetch_obj_r_simple; + } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) { + zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET]; + ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION); + ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array)); - if (IS_TMP_VAR == IS_CV) { - ZVAL_COPY_DEREF(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(result, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { - Z_ADDREF_P(result); - } - } - } - ZEND_VM_NEXT_OPCODE(); -} + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if ((IS_TMP_VAR|IS_VAR) & IS_CV) { + GC_ADDREF(zobj); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) { + call_info |= ZEND_CALL_RELEASE_THIS; + } + zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj); + call->prev_execute_data = execute_data; + call->call = NULL; + call->return_value = EX_VAR(opline->result.var); + call->run_time_cache = RUN_TIME_CACHE(&hook->op_array); -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_FROM_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); - zval *val; + execute_data = call; + EG(current_execute_data) = execute_data; + zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); - SAVE_OPLINE(); - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); +#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) + opline = hook->op_array.opcodes; +#else + EX(opline) = hook->op_array.opcodes; +#endif + LOAD_OPLINE_EX(); - if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) { - zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator"); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } -yield_from_try_again: - if (Z_TYPE_P(val) == IS_ARRAY) { - ZVAL_COPY_VALUE(&generator->values, val); - if (Z_OPT_REFCOUNTED_P(val)) { - Z_ADDREF_P(val); - } - Z_FE_POS(generator->values) = 0; - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } else if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) { - zend_class_entry *ce = Z_OBJCE_P(val); - if (ce == zend_ce_generator) { - zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val); - Z_ADDREF_P(val); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (UNEXPECTED(new_gen->execute_data == NULL)) { - zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue"); - zval_ptr_dtor(val); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } else if (Z_ISUNDEF(new_gen->retval)) { - if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) { - zend_throw_error(NULL, "Impossible to yield from the Generator being currently run"); - zval_ptr_dtor(val); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } else { - zend_generator_yield_from(generator, new_gen); - } - } else { - if (RETURN_VALUE_USED(opline)) { - ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); - } - ZEND_VM_NEXT_OPCODE(); - } - } else { - zend_object_iterator *iter = ce->get_iterator(ce, val, 0); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_ENTER_EX(); + } + /* Fall through to read_property for hooks. */ + } else if (EXPECTED(zobj->properties != NULL)) { + ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { + uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); - if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) { - if (!EG(exception)) { - zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); - } - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } + if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { + Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); - iter->index = 0; - if (iter->funcs->rewind) { - iter->funcs->rewind(iter); - if (UNEXPECTED(EG(exception) != NULL)) { - OBJ_RELEASE(&iter->std); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); + if (EXPECTED(p->key == name) || + (EXPECTED(p->h == ZSTR_H(name)) && + EXPECTED(p->key != NULL) && + EXPECTED(zend_string_equal_content(p->key, name)))) { + retval = &p->val; + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { + goto fetch_obj_r_fast_copy; + } + } + } + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); + } + retval = zend_hash_find_known_hash(zobj->properties, name); + if (EXPECTED(retval)) { + uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { + goto fetch_obj_r_fast_copy; + } + } } } - - ZVAL_OBJ(&generator->values, &iter->std); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + break; + } } - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) { - val = Z_REFVAL_P(val); - goto yield_from_try_again; - } else { - zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables"); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } - /* This is the default return value - * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ - if (RETURN_VALUE_USED(opline)) { - ZVAL_NULL(EX_VAR(opline->result.var)); - } +#if ZEND_DEBUG + /* For non-standard object handlers, verify a declared property type in debug builds. + * Fetch prop_info before calling read_property(), as it may deallocate the object. */ + zend_property_info *prop_info = NULL; + if (zobj->handlers->read_property != zend_std_read_property) { + prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true); + } +#endif + retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var)); +#if ZEND_DEBUG + if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO + && ZEND_TYPE_IS_SET(prop_info->type)) { + ZVAL_OPT_DEREF(retval); + zend_verify_property_type(prop_info, retval, /* strict */ true); + } +#endif - /* This generator has no send target (though the generator we delegate to might have one) */ - generator->send_target = NULL; + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - /* The GOTO VM uses a local opline variable. We need to set the opline - * variable in execute_data so we don't resume at an old position. */ - SAVE_OPLINE(); + if (retval != EX_VAR(opline->result.var)) { +fetch_obj_r_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_unwrap_reference(retval); + } + } while (0); - ZEND_VM_RETURN(); +fetch_obj_r_finish: + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_STRLEN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; - - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(value); - } - ZEND_VM_NEXT_OPCODE(); - } else { - bool strict; + zval *container; + void **cache_slot = NULL; - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) { - value = Z_REFVAL_P(value); - if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); - } - } + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - value = ZVAL_UNDEFINED_OP1(); - } - strict = EX_USES_STRICT_TYPES(); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if (EXPECTED(!strict)) { - zend_string *str; - zval tmp; - - if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) { - zend_error(E_DEPRECATED, - "strlen(): Passing null to parameter #1 ($string) of type string is deprecated"); - ZVAL_LONG(EX_VAR(opline->result.var), 0); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - break; - } - - ZVAL_COPY(&tmp, value); - if (zend_parse_arg_str_weak(&tmp, &str, 1)) { - ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); - zval_ptr_dtor(&tmp); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; } - zval_ptr_dtor(&tmp); } - if (!EG(exception)) { - zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + ZVAL_UNDEFINED_OP2(); } - ZVAL_UNDEF(EX_VAR(opline->result.var)); + ZVAL_NULL(EX_VAR(opline->result.var)); + goto fetch_obj_is_finish; } while (0); } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_TYPE_CHECK_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - int result = 0; + /* here we are sure we are dealing with an object */ + do { + zend_object *zobj = Z_OBJ_P(container); + zend_string *name, *tmp_name; + zval *retval; - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { -type_check_resource: - if (opline->extended_value != MAY_BE_RESOURCE - || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { - result = 1; - } - } else if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { - goto type_check_resource; - } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); - } else { - ZEND_VM_SMART_BRANCH(result, 0); - } -} + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + cache_slot = CACHE_ADDR(opline->extended_value); -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - uint32_t fetch_type; - zend_class_entry *called_scope, *scope; - USE_OPLINE + if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - if (IS_TMP_VAR != IS_UNUSED) { - SAVE_OPLINE(); - zval *op = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) { - ZVAL_DEREF(op); - if (Z_TYPE_P(op) != IS_OBJECT) { - zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op)); + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { +fetch_obj_is_simple: + retval = OBJ_PROP(zobj, prop_offset); + if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) { + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { +fetch_obj_is_fast_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); + } + } + } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { + zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + goto fetch_obj_is_simple; + } + /* Fall through to read_property for hooks. */ + } else if (EXPECTED(zobj->properties != NULL)) { + ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { + uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + + if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { + Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + + if (EXPECTED(p->key == name) || + (EXPECTED(p->h == ZSTR_H(name)) && + EXPECTED(p->key != NULL) && + EXPECTED(zend_string_equal_content(p->key, name)))) { + retval = &p->val; + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { + goto fetch_obj_is_fast_copy; + } + } + } + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); + } + retval = zend_hash_find_known_hash(zobj->properties, name); + if (EXPECTED(retval)) { + uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { + goto fetch_obj_is_fast_copy; + } + } + } + } + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + break; } } - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } + retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - fetch_type = opline->op1.num; - scope = EX(func)->op_array.scope; - if (UNEXPECTED(scope == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, "Cannot use \"%s\" in the global scope", - fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : - fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - switch (fetch_type) { - case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); - break; - case ZEND_FETCH_CLASS_PARENT: - if (UNEXPECTED(scope->parent == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, - "Cannot use \"parent\" when current class scope has no parent"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); - break; - case ZEND_FETCH_CLASS_STATIC: - if (Z_TYPE(EX(This)) == IS_OBJECT) { - called_scope = Z_OBJCE(EX(This)); - } else { - called_scope = Z_CE(EX(This)); - } - ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name); - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - ZEND_VM_NEXT_OPCODE(); + if (retval != EX_VAR(opline->result.var)) { +fetch_obj_is_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_unwrap_reference(retval); + } + } while (0); + +fetch_obj_is_finish: + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - div_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - pow_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_string *op1_str, *op2_str, *str; - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { size_t len = ZSTR_LEN(op1_str); - if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { - zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); - } str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -18320,2525 +18587,2766 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_T memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } ZEND_VM_NEXT_OPCODE(); - } else { - SAVE_OPLINE(); + } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - op1 = ZVAL_UNDEFINED_OP1(); + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + op1_str = Z_STR_P(op1); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + op1_str = zend_string_copy(Z_STR_P(op1)); + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - op2 = ZVAL_UNDEFINED_OP2(); + op1_str = zval_get_string_func(op1); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + op2_str = Z_STR_P(op2); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + op2_str = zend_string_copy(Z_STR_P(op2)); + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); } - concat_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + op2_str = zval_get_string_func(op2); } -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { + GC_ADDREF(op2_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + zend_string_release_ex(op1_str, 0); + break; + } + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { + GC_ADDREF(op1_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + zend_string_release_ex(op2_str, 0); + break; + } + } + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - result = fast_is_identical_function(op1, op2); + ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_string_release_ex(op1_str, 0); + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_string_release_ex(op2_str, 0); + } + } while (0); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_SMART_BRANCH(result, 1); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - bool result; + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - result = fast_is_identical_function(op1, op2); + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - ZEND_VM_SMART_BRANCH(result, 1); -} + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); + } - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - result = fast_is_not_identical_function(op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + obj = Z_OBJ_P(object); + } else { + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + } else { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + zend_reference *ref = Z_REF_P(object); + object = &ref->val; + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else { + Z_ADDREF_P(object); + } + } + break; + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + HANDLE_EXCEPTION(); + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + zend_invalid_method_call(object, function_name); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } while (0); + } - ZEND_VM_SMART_BRANCH(result, 1); -} + called_scope = obj->ce; -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + GC_ADDREF(obj); /* For $this pointer */ + if (GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { + zend_objects_store_del(obj); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); } } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); +case_true: + ZEND_VM_SMART_BRANCH_TRUE(); } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); +case_false: + ZEND_VM_SMART_BRANCH_FALSE(); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); d2 = Z_DVAL_P(op2); - goto is_equal_double; + goto case_double; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = Z_DVAL_P(op1); d2 = Z_DVAL_P(op2); -is_equal_double: +case_double: if (d1 == d2) { - goto is_equal_true; + goto case_true; } else { - goto is_equal_false; + goto case_false; } } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { d1 = Z_DVAL_P(op1); d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; + goto case_double; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (result) { - goto is_equal_true; + goto case_true; } else { - goto is_equal_false; + goto case_false; } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *container; + bool result; + zend_ulong hval; + zval *offset; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + HashTable *ht; + zval *value; + zend_string *str; + +isset_dim_obj_array: + ht = Z_ARRVAL_P(container); +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; + value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + offset = Z_REFVAL_P(offset); + goto isset_again; + } else { + value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); + if (UNEXPECTED(EG(exception))) { + result = 0; + goto isset_dim_obj_exit; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; + + if (!(opline->extended_value & ZEND_ISEMPTY)) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + + if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { + /* avoid exception check */ + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 0); } + } else { + result = (value == NULL || !i_zend_is_true(value)); + } + goto isset_dim_obj_exit; + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto isset_dim_obj_array; } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + offset++; + } + if (!(opline->extended_value & ZEND_ISEMPTY)) { + result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); + } else { + result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); + } + +isset_dim_obj_exit: + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *container; + int result; + zval *offset; + zend_string *name, *tmp_name; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; + } else { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; - } + } + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + name = Z_STR_P(offset); + } else { + name = zval_try_get_tmp_string(offset, &tmp_name); + if (UNEXPECTED(!name)) { + result = 0; + goto isset_object_finish; } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + result = + (opline->extended_value & ZEND_ISEMPTY) ^ + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +isset_object_finish: + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + zval *key, *subject; + HashTable *ht; + bool result; + + SAVE_OPLINE(); + + key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { +array_key_exists_array: + ht = Z_ARRVAL_P(subject); + result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); + } else { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + subject = Z_REFVAL_P(subject); + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { + goto array_key_exists_array; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); + zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); + result = 0; + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + bool result; + + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + +try_instanceof: + if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; + + if (IS_VAR == IS_CONST) { + ce = CACHED_PTR(cache_slot); + if (UNEXPECTED(ce == NULL)) { + ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); + if (EXPECTED(ce)) { + CACHE_PTR(cache_slot, ce); + } } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + } else if (IS_VAR == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + } else { + ce = Z_CE_P(EX_VAR(opline->op2.var)); + } + result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_VAR == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; } + /* If no expected_args, just check the base class (already done) */ + } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { + expr = Z_REFVAL_P(expr); + goto try_instanceof; + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } + result = 0; } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV_EX zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_EX int type) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *varname; + zval *retval; + zend_string *name, *tmp_name; + HashTable *target_symbol_table; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + SAVE_OPLINE(); + varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + name = Z_STR_P(varname); + } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { + name = Z_STR_P(varname); + tmp_name = NULL; + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + name = zval_try_get_tmp_string(varname, &tmp_name); + if (UNEXPECTED(!name)) { + if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + } + + target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); + retval = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST); + if (retval == NULL) { + if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) { +fetch_this: + zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); + if (type == BP_VAR_W) { + retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval)); + } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) { + retval = &EG(uninitialized_zval); + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + /* Keep name alive in case an error handler tries to free it. */ + zend_string_addref(name); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + zend_error_unchecked(E_WARNING, "Undefined %svariable $%S", + (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name); + if (type == BP_VAR_RW && !EG(exception)) { + retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval)); + } else { + retval = &EG(uninitialized_zval); } - if (!result) { - goto is_not_equal_true; + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + zend_string_release(name); + } + } + /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ + } else if (Z_TYPE_P(retval) == IS_INDIRECT) { + retval = Z_INDIRECT_P(retval); + if (Z_TYPE_P(retval) == IS_UNDEF) { + if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) { + goto fetch_this; + } + if (type == BP_VAR_W) { + ZVAL_NULL(retval); + } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) { + retval = &EG(uninitialized_zval); } else { - goto is_not_equal_false; + zend_error_unchecked(E_WARNING, "Undefined %svariable $%S", + (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name); + if (type == BP_VAR_RW && !EG(exception)) { + ZVAL_NULL(retval); + } else { + retval = &EG(uninitialized_zval); + } } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - compare_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + ZEND_ASSERT(retval != NULL); + if (type == BP_VAR_R || type == BP_VAR_IS) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else { + ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); + } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - USE_OPLINE - zval *op1, *op2; + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R)); +} - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - boolean_xor_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W)); +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW)); +} - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + int fetch_type = + (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ? + BP_VAR_W : BP_VAR_R; + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { -#if 0 - USE_OPLINE -#endif + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET)); +} - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } else { - if (IS_CONST == IS_UNUSED) { - ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - if (IS_TMP_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { -#if 0 USE_OPLINE -#endif + zval *value, *arg; - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - /* Behave like FETCH_OBJ_W */ - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } - ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - zend_string *op1_str, *op2_str, *str; - + zval *varname; + zend_string *name, *tmp_name; + HashTable *target_symbol_table; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); + SAVE_OPLINE(); - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); + varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + name = Z_STR_P(varname); + } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { + name = Z_STR_P(varname); + tmp_name = NULL; + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { + varname = ZVAL_UNDEFINED_OP1(); } - ZEND_VM_NEXT_OPCODE(); + name = zval_try_get_tmp_string(varname, &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + + target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); + zend_hash_del_ind(target_symbol_table, name); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + bool result; + zval *varname; + zend_string *name, *tmp_name; + HashTable *target_symbol_table; SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CONST) { - op1_str = Z_STR_P(op1); - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - op1_str = zend_string_copy(Z_STR_P(op1)); + varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + name = Z_STR_P(varname); } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - op1_str = zval_get_string_func(op1); + name = zval_get_tmp_string(varname, &tmp_name); } - if (IS_CONST == IS_CONST) { - op2_str = Z_STR_P(op2); - } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - op2_str = zend_string_copy(Z_STR_P(op2)); - } else { - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - } - op2_str = zval_get_string_func(op2); + + target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); + value = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); } - do { - if (IS_TMP_VAR != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { - GC_ADDREF(op2_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - zend_string_release_ex(op1_str, 0); - break; - } - } - if (IS_CONST != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { - GC_ADDREF(op1_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - zend_string_release_ex(op2_str, 0); - break; - } - } - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR != IS_CONST) { - zend_string_release_ex(op1_str, 0); + if (!value) { + result = (opline->extended_value & ZEND_ISEMPTY); + } else { + if (Z_TYPE_P(value) == IS_INDIRECT) { + value = Z_INDIRECT_P(value); } - if (IS_CONST != IS_CONST) { - zend_string_release_ex(op2_str, 0); + if (!(opline->extended_value & ZEND_ISEMPTY)) { + if (Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + } + result = Z_TYPE_P(value) > IS_NULL; + } else { + result = !i_zend_is_true(value); } - } while (0); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - + } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_SMART_BRANCH(result, true); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_string **rope; - zval *var; + zval *expr; + bool result; - /* op1 and result are the same */ - rope = (zend_string**)EX_VAR(opline->op1.var); - if (IS_CONST == IS_CONST) { - var = RT_CONSTANT(opline, opline->op2); - rope[opline->extended_value] = Z_STR_P(var); - if (UNEXPECTED(Z_REFCOUNTED_P(var))) { - Z_ADDREF_P(var); - } - } else { - var = RT_CONSTANT(opline, opline->op2); - if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_CONST == IS_CV) { - rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); - } else { - rope[opline->extended_value] = Z_STR_P(var); + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + +try_instanceof: + if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; + + if (IS_UNUSED == IS_CONST) { + ce = CACHED_PTR(cache_slot); + if (UNEXPECTED(ce == NULL)) { + ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); + if (EXPECTED(ce)) { + CACHE_PTR(cache_slot, ce); + } } - } else { - SAVE_OPLINE(); - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); + } else if (IS_UNUSED == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - rope[opline->extended_value] = zval_get_string_func(var); - + } else { + ce = Z_CE_P(EX_VAR(opline->op2.var)); + } + result = ce && instanceof_function(Z_OBJCE_P(expr), ce); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + /* Check generic type arguments if present */ + if (result && IS_UNUSED == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { + expr = Z_REFVAL_P(expr); + goto try_instanceof; + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } + result = 0; } - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_string **rope; - zval *var, *ret; - uint32_t i; + zval *op1; + zend_long count; - rope = (zend_string**)EX_VAR(opline->op1.var); - if (IS_CONST == IS_CONST) { - var = RT_CONSTANT(opline, opline->op2); - rope[opline->extended_value] = Z_STR_P(var); - if (UNEXPECTED(Z_REFCOUNTED_P(var))) { - Z_ADDREF_P(var); - } - } else { - var = RT_CONSTANT(opline, opline->op2); - if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_CONST == IS_CV) { - rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); - } else { - rope[opline->extended_value] = Z_STR_P(var); - } - } else { - SAVE_OPLINE(); - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - } - rope[opline->extended_value] = zval_get_string_func(var); + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + while (1) { + if (Z_TYPE_P(op1) == IS_ARRAY) { + count = zend_hash_num_elements(Z_ARRVAL_P(op1)); + break; + } else if (Z_TYPE_P(op1) == IS_OBJECT) { + zend_object *zobj = Z_OBJ_P(op1); - if (UNEXPECTED(EG(exception))) { - for (i = 0; i <= opline->extended_value; i++) { - zend_string_release_ex(rope[i], 0); + /* first, we check if the handler is defined */ + if (zobj->handlers->count_elements) { + if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) { + break; } - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + if (UNEXPECTED(EG(exception))) { + count = 0; + break; + } + } + + /* if not and the object implements Countable we call its count() method */ + if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) { + zval retval; + + zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT)); + zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval); + count = zval_get_long(&retval); + zval_ptr_dtor(&retval); + break; } + + /* If There's no handler and it doesn't implement Countable then emit a TypeError */ + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + continue; + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } + count = 0; + zend_type_error("%s(): Argument #1 ($value) must be of type Countable|array, %s given", opline->extended_value ? "sizeof" : "count", zend_zval_value_name(op1)); + break; } - size_t len = 0; - uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES; - for (i = 0; i <= opline->extended_value; i++) { - flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]); - len += ZSTR_LEN(rope[i]); - } - ret = EX_VAR(opline->result.var); - ZVAL_STR(ret, zend_string_alloc(len, 0)); - GC_ADD_FLAGS(Z_STR_P(ret), flags); + ZVAL_LONG(EX_VAR(opline->result.var), count); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} - char *target = Z_STRVAL_P(ret); - for (i = 0; i <= opline->extended_value; i++) { - memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i])); - target += ZSTR_LEN(rope[i]); - zend_string_release_ex(rope[i], 0); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC)); + ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + SAVE_OPLINE(); + zend_array_destroy(ht); + if (EG(exception)) { + HANDLE_EXCEPTION(); + } } - *target = '\0'; - ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - SAVE_OPLINE(); - - object = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - if (IS_CONST != IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + SAVE_OPLINE(); + if (UNEXPECTED(!EX(func)->common.scope)) { + zend_throw_error(NULL, "get_class() without arguments must be called from within a class"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } else { + zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); + ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); + } + } else { + zval *op1; - if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + while (1) { + if (Z_TYPE_P(op1) == IS_OBJECT) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + continue; + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } + zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); } - zend_throw_error(NULL, "Method name must be a string"); + break; + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + zval *result = EX_VAR(opline->result.var); + ZVAL_COPY(result, value); + ZEND_VM_NEXT_OPCODE(); +} - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } while (0); - } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; - if (IS_TMP_VAR == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + div_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_TMP_VAR & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST) { + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} - } - HANDLE_EXCEPTION(); - } - } - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - zend_invalid_method_call(object, function_name); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + pow_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } while (0); - } - called_scope = obj->ce; + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} - if (IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = EX_VAR(opline->op2.var); - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); - } + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CV == IS_CONST || IS_CV == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + } + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); + if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { + zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); } - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else { + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - } - } + ZEND_VM_NEXT_OPCODE(); + } else { + SAVE_OPLINE(); - if (IS_CONST != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + op1 = ZVAL_UNDEFINED_OP1(); + } + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + op2 = ZVAL_UNDEFINED_OP2(); + } + concat_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +} - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_TMP_VAR == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + compare_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value, *arg; - uint32_t arg_num; + zval *container, *dim, *value; - if (IS_CONST == IS_CONST) { - SAVE_OPLINE(); - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!arg)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + dim = EX_VAR(opline->op2.var); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +fetch_dim_r_array: + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC); + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto fetch_dim_r_array; + } else { + goto fetch_dim_r_slow; + } + } else { +fetch_dim_r_slow: + if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } } else { - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; + zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC); } - if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { - if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_val_by_ref; - } - } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_val_by_ref:; - ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg)); - } - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - ZVAL_COPY_VALUE(arg, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); - } - } - ZEND_VM_NEXT_OPCODE(); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *container; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -case_true: - ZEND_VM_SMART_BRANCH_TRUE(); - } else { -case_false: - ZEND_VM_SMART_BRANCH_FALSE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -case_double: - if (d1 == d2) { - goto case_true; - } else { - goto case_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC); - if (result) { - goto case_true; - } else { - goto case_false; - } - } - } - ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *expr_ptr, new_expr; + zval *container; + void **cache_slot = NULL; SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && - UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { - expr_ptr = zend_get_bad_ptr(); - if (Z_ISREF_P(expr_ptr)) { - Z_ADDREF_P(expr_ptr); - } else { - ZVAL_MAKE_REF_EX(expr_ptr, 2); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } else { - expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_TMP_VAR) { - /* pass */ - } else if (IS_TMP_VAR == IS_CONST) { - Z_TRY_ADDREF_P(expr_ptr); - } else if (IS_TMP_VAR == IS_CV) { - ZVAL_DEREF(expr_ptr); - Z_TRY_ADDREF_P(expr_ptr); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(expr_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(expr_ptr); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - expr_ptr = Z_REFVAL_P(expr_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - ZVAL_COPY_VALUE(&new_expr, expr_ptr); - expr_ptr = &new_expr; - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) { - Z_ADDREF_P(expr_ptr); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + break; } } - } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + ZVAL_NULL(EX_VAR(opline->result.var)); + goto fetch_obj_r_finish; + } while (0); } - if (IS_CONST != IS_UNUSED) { - zval *offset = RT_CONSTANT(opline, opline->op2); - zend_string *str; - zend_ulong hval; + /* here we are sure we are dealing with an object */ + do { + zend_object *zobj = Z_OBJ_P(container); + zend_string *name, *tmp_name; + zval *retval; -add_again: - if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - if (IS_CONST != IS_CONST) { - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index; - } - } -str_index: - zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index: - zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto add_again; - } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { - zval tmp; - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - ZVAL_COPY(&tmp, expr_ptr); - } - zend_error(E_DEPRECATED, "Using null as an array offset is deprecated, use an empty string instead"); - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - /* A userland error handler can do funky things to the expression, so reset it */ - zval_ptr_dtor(expr_ptr); - ZVAL_COPY_VALUE(expr_ptr, &tmp); - } - if (UNEXPECTED(EG(exception))) { - zval_ptr_dtor_nogc(expr_ptr); - HANDLE_EXCEPTION(); + if (IS_CV == IS_CONST) { + cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); + + if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { +fetch_obj_r_simple: + retval = OBJ_PROP(zobj, prop_offset); + if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) { + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { +fetch_obj_r_fast_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); + } + } + } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { + zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { + prop_offset = prop_info->offset; + goto fetch_obj_r_simple; + } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) { + zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET]; + ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION); + ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array)); + + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if ((IS_TMP_VAR|IS_VAR) & IS_CV) { + GC_ADDREF(zobj); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) { + call_info |= ZEND_CALL_RELEASE_THIS; + } + zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj); + call->prev_execute_data = execute_data; + call->call = NULL; + call->return_value = EX_VAR(opline->result.var); + call->run_time_cache = RUN_TIME_CACHE(&hook->op_array); + + execute_data = call; + EG(current_execute_data) = execute_data; + zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); + +#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) + opline = hook->op_array.opcodes; +#else + EX(opline) = hook->op_array.opcodes; +#endif + LOAD_OPLINE_EX(); + + + + + ZEND_VM_ENTER_EX(); + } + /* Fall through to read_property for hooks. */ + } else if (EXPECTED(zobj->properties != NULL)) { + ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { + uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + + if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { + Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + + if (EXPECTED(p->key == name) || + (EXPECTED(p->h == ZSTR_H(name)) && + EXPECTED(p->key != NULL) && + EXPECTED(zend_string_equal_content(p->key, name)))) { + retval = &p->val; + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { + goto fetch_obj_r_fast_copy; + } + } + } + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); + } + retval = zend_hash_find_known_hash(zobj->properties, name); + if (EXPECTED(retval)) { + uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { + goto fetch_obj_r_fast_copy; + } + } + } } - str = ZSTR_EMPTY_ALLOC(); - goto str_index; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); - goto num_index; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); - goto num_index; - } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { - ZVAL_UNDEFINED_OP2(); - str = ZSTR_EMPTY_ALLOC(); - goto str_index; + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); } else { - zend_illegal_array_offset_access(offset); - zval_ptr_dtor_nogc(expr_ptr); + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + break; + } } - - } else { - if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_cannot_add_element(); - zval_ptr_dtor_nogc(expr_ptr); +#if ZEND_DEBUG + /* For non-standard object handlers, verify a declared property type in debug builds. + * Fetch prop_info before calling read_property(), as it may deallocate the object. */ + zend_property_info *prop_info = NULL; + if (zobj->handlers->read_property != zend_std_read_property) { + prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true); } - } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} +#endif + retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var)); +#if ZEND_DEBUG + if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO + && ZEND_TYPE_IS_SET(prop_info->type)) { + ZVAL_OPT_DEREF(retval); + zend_verify_property_type(prop_info, retval, /* strict */ true); + } +#endif -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - zval *array; - uint32_t size; - USE_OPLINE + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - SAVE_OPLINE(); - array = EX_VAR(opline->result.var); - if (IS_TMP_VAR != IS_UNUSED) { - size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; - ZVAL_ARR(array, zend_new_array(size)); - /* Explicitly initialize array as not-packed if flag is set */ - if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { - zend_hash_real_init_mixed(Z_ARRVAL_P(array)); + if (retval != EX_VAR(opline->result.var)) { +fetch_obj_r_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_unwrap_reference(retval); } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } else { - ZVAL_ARR(array, zend_new_array(0)); - ZEND_VM_NEXT_OPCODE(); - } + } while (0); + +fetch_obj_r_finish: + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; - bool result; - zend_ulong hval; - zval *offset; + void **cache_slot = NULL; SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = RT_CONSTANT(opline, opline->op2); - - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - HashTable *ht; - zval *value; - zend_string *str; + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); -isset_dim_obj_array: - ht = Z_ARRVAL_P(container); -isset_again: - if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - if (IS_CONST != IS_CONST) { - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_prop; + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + break; } } - value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_prop: - value = zend_hash_index_find(ht, hval); - } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { - offset = Z_REFVAL_P(offset); - goto isset_again; - } else { - value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); - if (UNEXPECTED(EG(exception))) { - result = 0; - goto isset_dim_obj_exit; + if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + ZVAL_UNDEFINED_OP2(); } - } + ZVAL_NULL(EX_VAR(opline->result.var)); + goto fetch_obj_is_finish; + } while (0); + } - if (!(opline->extended_value & ZEND_ISEMPTY)) { - /* > IS_NULL means not IS_UNDEF and not IS_NULL */ - result = value != NULL && Z_TYPE_P(value) > IS_NULL && - (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + /* here we are sure we are dealing with an object */ + do { + zend_object *zobj = Z_OBJ_P(container); + zend_string *name, *tmp_name; + zval *retval; - if (IS_TMP_VAR & (IS_CONST|IS_CV)) { - /* avoid exception check */ + if (IS_CV == IS_CONST) { + cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - ZEND_VM_SMART_BRANCH(result, 0); + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { +fetch_obj_is_simple: + retval = OBJ_PROP(zobj, prop_offset); + if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) { + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { +fetch_obj_is_fast_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); + } + } + } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { + zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + goto fetch_obj_is_simple; + } + /* Fall through to read_property for hooks. */ + } else if (EXPECTED(zobj->properties != NULL)) { + ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { + uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + + if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { + Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + + if (EXPECTED(p->key == name) || + (EXPECTED(p->h == ZSTR_H(name)) && + EXPECTED(p->key != NULL) && + EXPECTED(zend_string_equal_content(p->key, name)))) { + retval = &p->val; + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { + goto fetch_obj_is_fast_copy; + } + } + } + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); + } + retval = zend_hash_find_known_hash(zobj->properties, name); + if (EXPECTED(retval)) { + uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { + goto fetch_obj_is_fast_copy; + } + } + } } + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); } else { - result = (value == NULL || !i_zend_is_true(value)); + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + break; + } } - goto isset_dim_obj_exit; - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto isset_dim_obj_array; + + retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); + + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); } - } - if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { - offset++; - } - if (!(opline->extended_value & ZEND_ISEMPTY)) { - result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); - } else { - result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); - } + if (retval != EX_VAR(opline->result.var)) { +fetch_obj_is_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_unwrap_reference(retval); + } + } while (0); -isset_dim_obj_exit: +fetch_obj_is_finish: zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - int result; - zval *offset; - zend_string *name, *tmp_name; + zval *op1, *op2; + zend_string *op1_str, *op2_str, *str; - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = RT_CONSTANT(opline, opline->op2); - if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = EX_VAR(opline->op2.var); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CV == IS_CONST || IS_CV == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + } + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); + + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } } else { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } } + ZEND_VM_NEXT_OPCODE(); } - if (IS_CONST == IS_CONST) { - name = Z_STR_P(offset); + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + op1_str = Z_STR_P(op1); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + op1_str = zend_string_copy(Z_STR_P(op1)); } else { - name = zval_try_get_tmp_string(offset, &tmp_name); - if (UNEXPECTED(!name)) { - result = 0; - goto isset_object_finish; + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } + op1_str = zval_get_string_func(op1); } - - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - - if (IS_CONST != IS_CONST) { - zend_tmp_string_release(tmp_name); + if (IS_CV == IS_CONST) { + op2_str = Z_STR_P(op2); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + op2_str = zend_string_copy(Z_STR_P(op2)); + } else { + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + } + op2_str = zval_get_string_func(op2); } + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { + GC_ADDREF(op2_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + zend_string_release_ex(op1_str, 0); + break; + } + } + if (IS_CV != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { + GC_ADDREF(op1_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + zend_string_release_ex(op2_str, 0); + break; + } + } + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); -isset_object_finish: + ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CV != IS_CONST) { + zend_string_release_ex(op2_str, 0); + } + } while (0); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - - zval *key, *subject; - HashTable *ht; - bool result; + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; SAVE_OPLINE(); - key = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - subject = RT_CONSTANT(opline, opline->op2); + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { -array_key_exists_array: - ht = Z_ARRVAL_P(subject); - result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); - } else { - if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { - subject = Z_REFVAL_P(subject); - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { - goto array_key_exists_array; - } - } - zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); - result = 0; + if (IS_CV != IS_CONST) { + function_name = EX_VAR(opline->op2.var); } + if (IS_CV != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *expr; - bool result; - - SAVE_OPLINE(); - expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - -try_instanceof: - if (Z_TYPE_P(expr) == IS_OBJECT) { - zend_class_entry *ce; - - if (IS_CONST == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); - if (UNEXPECTED(ce == NULL)) { - ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); - if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); - } - } - } else if (IS_CONST == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op2.num); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op2.var)); - } - result = ce && instanceof_function(Z_OBJCE_P(expr), ce); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { - expr = Z_REFVAL_P(expr); - goto try_instanceof; - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - result = 0; - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - - zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); - - SAVE_OPLINE(); - if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) { - ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); } - /* Destroy the previously yielded value */ - zval_ptr_dtor(&generator->value); - - /* Destroy the previously yielded key */ - zval_ptr_dtor(&generator->key); - - /* Set the new yielded value */ - if (IS_TMP_VAR != IS_UNUSED) { - if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) { - /* Constants and temporary variables aren't yieldable by reference, - * but we still allow them with a notice. */ - if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) { - zval *value; - - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - ZVAL_COPY_VALUE(&generator->value, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) { - Z_ADDREF(generator->value); - } - } + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + obj = Z_OBJ_P(object); + } else { + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); } else { - zval *value_ptr = zend_get_bad_ptr(); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + zend_reference *ref = Z_REF_P(object); - /* If a function call result is yielded and the function did - * not return by reference we throw a notice. */ - do { - if (IS_TMP_VAR == IS_VAR) { - ZEND_ASSERT(value_ptr != &EG(uninitialized_zval)); - if (opline->extended_value == ZEND_RETURNS_FUNCTION - && !Z_ISREF_P(value_ptr)) { - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - ZVAL_COPY(&generator->value, value_ptr); - break; + object = &ref->val; + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else { + Z_ADDREF_P(object); + } } + break; } - if (Z_ISREF_P(value_ptr)) { - Z_ADDREF_P(value_ptr); - } else { - ZVAL_MAKE_REF_EX(value_ptr, 2); - } - ZVAL_REF(&generator->value, Z_REF_P(value_ptr)); - } while (0); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CV != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } - } else { - zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST) { - ZVAL_COPY_VALUE(&generator->value, value); - if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) { - Z_ADDREF(generator->value); + } + HANDLE_EXCEPTION(); + } } - } else if (IS_TMP_VAR == IS_TMP_VAR) { - ZVAL_COPY_VALUE(&generator->value, value); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { - ZVAL_COPY(&generator->value, Z_REFVAL_P(value)); + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + zend_invalid_method_call(object, function_name); - } else { - ZVAL_COPY_VALUE(&generator->value, value); - if (IS_TMP_VAR == IS_CV) { - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); - } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } - } - } else { - /* If no value was specified yield null */ - ZVAL_NULL(&generator->value); + } while (0); } - /* Set the new yielded key */ - if (IS_CONST != IS_UNUSED) { - zval *key = RT_CONSTANT(opline, opline->op2); - if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { - key = Z_REFVAL_P(key); - } - ZVAL_COPY(&generator->key, key); - - - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key - ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); - } - } else { - /* If no key was specified we use auto-increment keys */ - generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); - } + called_scope = obj->ce; - if (RETURN_VALUE_USED(opline)) { - /* If the return value of yield is used set the send - * target and initialize it to NULL */ - generator->send_target = EX_VAR(opline->result.var); - ZVAL_NULL(generator->send_target); + if (IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { - generator->send_target = NULL; - } - - /* The GOTO VM uses a local opline variable. We need to set the opline - * variable in execute_data so we don't resume at an old position. */ - SAVE_OPLINE(); + zend_object *orig_obj = obj; - ZEND_VM_RETURN(); -} + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1; - HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); - zval *result; + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); + } - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - ZEND_VM_SMART_BRANCH(result, 0); - } - if (opline->extended_value) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); - } - SAVE_OPLINE(); - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { - op1 = Z_REFVAL_P(op1); - if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - result = zend_hash_find(ht, Z_STR_P(op1)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); + HANDLE_EXCEPTION(); } - } else if (Z_TYPE_P(op1) <= IS_FALSE) { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); } - result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); - ZEND_VM_SMART_BRANCH(result, 0); - } else { - zend_string *key; - zval key_tmp; - - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { - op1 = Z_REFVAL_P(op1); - if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - result = zend_hash_find(ht, Z_STR_P(op1)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + GC_ADDREF(obj); /* For $this pointer */ + if (GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); } } - - SAVE_OPLINE(); - ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) { - ZVAL_STR(&key_tmp, key); - if (zend_compare(op1, &key_tmp) == 0) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(1, 1); - } - } ZEND_HASH_FOREACH_END(); + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(0, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - div_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - pow_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if (IS_CV != IS_CONST) { - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); + } - if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { - zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); - } - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { + zend_objects_store_del(obj); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); } } - ZEND_VM_NEXT_OPCODE(); - } else { - SAVE_OPLINE(); - - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - op1 = ZVAL_UNDEFINED_OP1(); - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - op2 = ZVAL_UNDEFINED_OP2(); + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ } - concat_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; } -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_identical_function(op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_identical_function(op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_not_identical_function(op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = EX_VAR(opline->op2.var); + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); +case_true: + ZEND_VM_SMART_BRANCH_TRUE(); } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); +case_false: + ZEND_VM_SMART_BRANCH_FALSE(); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); d2 = Z_DVAL_P(op2); - goto is_equal_double; + goto case_double; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = Z_DVAL_P(op1); d2 = Z_DVAL_P(op2); -is_equal_double: +case_double: if (d1 == d2) { - goto is_equal_true; + goto case_true; } else { - goto is_equal_false; + goto case_false; } } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { d1 = Z_DVAL_P(op1); d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; + goto case_double; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } + + if (result) { - goto is_equal_true; + goto case_true; } else { - goto is_equal_false; + goto case_false; } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *container; + bool result; + zend_ulong hval; + zval *offset; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = EX_VAR(opline->op2.var); + + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + HashTable *ht; + zval *value; + zend_string *str; + +isset_dim_obj_array: + ht = Z_ARRVAL_P(container); +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; + value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + offset = Z_REFVAL_P(offset); + goto isset_again; + } else { + value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); + if (UNEXPECTED(EG(exception))) { + result = 0; + goto isset_dim_obj_exit; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; + + if (!(opline->extended_value & ZEND_ISEMPTY)) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + + if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { + /* avoid exception check */ + + + ZEND_VM_SMART_BRANCH(result, 0); } + } else { + result = (value == NULL || !i_zend_is_true(value)); + } + goto isset_dim_obj_exit; + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto isset_dim_obj_array; } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + offset++; + } + if (!(opline->extended_value & ZEND_ISEMPTY)) { + result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); + } else { + result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); + } + +isset_dim_obj_exit: + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *container; + int result; + zval *offset; + zend_string *name, *tmp_name; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; + } else { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; - } + } + + if (IS_CV == IS_CONST) { + name = Z_STR_P(offset); + } else { + name = zval_try_get_tmp_string(offset, &tmp_name); + if (UNEXPECTED(!name)) { + result = 0; + goto isset_object_finish; } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + result = + (opline->extended_value & ZEND_ISEMPTY) ^ + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +isset_object_finish: + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + zval *key, *subject; + HashTable *ht; + bool result; + + SAVE_OPLINE(); + + key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + subject = EX_VAR(opline->op2.var); + + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { +array_key_exists_array: + ht = Z_ARRVAL_P(subject); + result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); + } else { + if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + subject = Z_REFVAL_P(subject); + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { + goto array_key_exists_array; } } + zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); + result = 0; } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *retval_ptr; + zval *return_value; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; + + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + + + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + } else if (!return_value) { + if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + } else { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } } - if (!result) { - goto is_not_equal_true; + } else if (IS_TMP_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + SAVE_OPLINE(); + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } } else { - goto is_not_equal_false; + ZVAL_COPY_VALUE(return_value, retval_ptr); } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + + + + + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *retval_ptr; + zval *return_value; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + + SAVE_OPLINE(); + + return_value = EX(return_value); + + + do { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) || + (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { + /* Not supposed to happen, but we'll allow it */ + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (!return_value) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + break; + } + + ZVAL_NEW_REF(return_value, retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + Z_TRY_ADDREF_P(retval_ptr); + } } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; + break; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + + retval_ptr = zend_get_bad_ptr(); + + if (IS_TMP_VAR == IS_VAR) { + ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); + if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + if (return_value) { + ZVAL_NEW_REF(return_value, retval_ptr); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } + break; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (!result) { - goto is_not_equal_true; + + if (return_value) { + if (Z_ISREF_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); } else { - goto is_not_equal_false; + ZVAL_MAKE_REF_EX(retval_ptr, 2); } + ZVAL_REF(return_value, Z_REF_P(retval_ptr)); } - } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); -} -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } while (0); - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - compare_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - boolean_xor_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { -#if 0 USE_OPLINE -#endif + zval *retval; - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } else { - if (IS_TMP_VAR == IS_UNUSED) { - ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + + SAVE_OPLINE(); + retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + /* Copy return value into generator->retval */ + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(&generator->retval, retval); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { + Z_ADDREF(generator->retval); + } } - if (IS_TMP_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); + } else if (IS_TMP_VAR == IS_CV) { + ZVAL_COPY_DEREF(&generator->retval, retval); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_refcounted *ref = Z_COUNTED_P(retval); + + retval = Z_REFVAL_P(retval); + ZVAL_COPY_VALUE(&generator->retval, retval); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval)) { + Z_ADDREF_P(retval); } + } else { + ZVAL_COPY_VALUE(&generator->retval, retval); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } + + + EG(current_execute_data) = EX(prev_execute_data); + + /* Close the generator to free up resources */ + zend_generator_close(generator, 1); + + /* Pass execution back to handling code */ + ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { -#if 0 USE_OPLINE -#endif + zval *arg, *param; - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - /* Behave like FETCH_OBJ_W */ - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + SAVE_OPLINE(); + + arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); } else { - if (IS_TMP_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZVAL_COPY(param, arg); } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - zend_string *op1_str, *op2_str, *str; - + zval *expr; + zval *result = EX_VAR(opline->result.var); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); + SAVE_OPLINE(); + expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); - - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); + switch (opline->extended_value) { + case IS_LONG: + ZVAL_LONG(result, zval_get_long(expr)); + break; + case IS_DOUBLE: + ZVAL_DOUBLE(result, zval_get_double(expr)); + break; + case IS_STRING: + ZVAL_STR(result, zval_get_string(expr)); + break; + default: + ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead"); + if (IS_TMP_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); } - } - ZEND_VM_NEXT_OPCODE(); - } - - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CONST) { - op1_str = Z_STR_P(op1); - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - op1_str = zend_string_copy(Z_STR_P(op1)); - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - op1_str = zval_get_string_func(op1); - } - if (IS_TMP_VAR == IS_CONST) { - op2_str = Z_STR_P(op2); - } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - op2_str = zend_string_copy(Z_STR_P(op2)); - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - } - op2_str = zval_get_string_func(op2); - } - do { - if (IS_TMP_VAR != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + /* If value is already of correct type, return it directly */ + if (Z_TYPE_P(expr) == opline->extended_value) { + ZVAL_COPY_VALUE(result, expr); if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { - GC_ADDREF(op2_str); - } + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_TMP_VAR != IS_TMP_VAR) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); } - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - zend_string_release_ex(op1_str, 0); - break; + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - } - if (IS_TMP_VAR != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { - GC_ADDREF(op1_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - zend_string_release_ex(op2_str, 0); - break; + + if (opline->extended_value == IS_ARRAY) { + zend_cast_zval_to_array(result, expr, IS_TMP_VAR); + } else { + ZEND_ASSERT(opline->extended_value == IS_OBJECT); + zend_cast_zval_to_object(result, expr, IS_TMP_VAR); } - } - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + } - ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR != IS_CONST) { - zend_string_release_ex(op1_str, 0); - } - if (IS_TMP_VAR != IS_CONST) { - zend_string_release_ex(op2_str, 0); - } - } while (0); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_string **rope; - zval *var; + zval *array_ptr, *result; - /* op1 and result are the same */ - rope = (zend_string**)EX_VAR(opline->op1.var); - if (IS_TMP_VAR == IS_CONST) { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - rope[opline->extended_value] = Z_STR_P(var); - if (UNEXPECTED(Z_REFCOUNTED_P(var))) { - Z_ADDREF_P(var); + SAVE_OPLINE(); + + array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { + result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, array_ptr); + if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(array_ptr); } - } else { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_TMP_VAR == IS_CV) { - rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); + Z_FE_POS_P(result) = 0; + + + ZEND_VM_NEXT_OPCODE(); + } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { + zend_object *zobj = Z_OBJ_P(array_ptr); + if (!zobj->ce->get_iterator) { + if (UNEXPECTED(zend_object_is_lazy(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (UNEXPECTED(EG(exception))) { + UNDEF_RESULT(); + + + HANDLE_EXCEPTION(); + } + } + HashTable *properties = zobj->properties; + if (properties) { + if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(properties); + } + properties = zobj->properties = zend_array_dup(properties); + } } else { - rope[opline->extended_value] = Z_STR_P(var); + properties = zobj->handlers->get_properties(zobj); } - } else { - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); + + result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, array_ptr); + if (IS_TMP_VAR != IS_TMP_VAR) { + Z_ADDREF_P(array_ptr); } - rope[opline->extended_value] = zval_get_string_func(var); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - } - ZEND_VM_NEXT_OPCODE(); -} -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_END_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_string **rope; - zval *var, *ret; - uint32_t i; + if (zend_hash_num_elements(properties) == 0) { + Z_FE_ITER_P(result) = (uint32_t) -1; - rope = (zend_string**)EX_VAR(opline->op1.var); - if (IS_TMP_VAR == IS_CONST) { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - rope[opline->extended_value] = Z_STR_P(var); - if (UNEXPECTED(Z_REFCOUNTED_P(var))) { - Z_ADDREF_P(var); - } - } else { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_TMP_VAR == IS_CV) { - rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); - } else { - rope[opline->extended_value] = Z_STR_P(var); + + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } + + Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } else { - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - } - rope[opline->extended_value] = zval_get_string_func(var); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); if (UNEXPECTED(EG(exception))) { - for (i = 0; i <= opline->extended_value; i++) { - zend_string_release_ex(rope[i], 0); - } - ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); + } else if (is_empty) { + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else { + ZEND_VM_NEXT_OPCODE(); } } + } else { + zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } - - size_t len = 0; - uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES; - for (i = 0; i <= opline->extended_value; i++) { - flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]); - len += ZSTR_LEN(rope[i]); - } - ret = EX_VAR(opline->result.var); - ZVAL_STR(ret, zend_string_alloc(len, 0)); - GC_ADD_FLAGS(Z_STR_P(ret), flags); - - char *target = Z_STRVAL_P(ret); - for (i = 0; i <= opline->extended_value; i++) { - memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i])); - target += ZSTR_LEN(rope[i]); - zend_string_release_ex(rope[i], 0); - } - *target = '\0'; - - ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; + zval *array_ptr, *array_ref; SAVE_OPLINE(); - object = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - if (IS_TMP_VAR != IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { + array_ref = array_ptr = zend_get_bad_ptr(); + if (Z_ISREF_P(array_ref)) { + array_ptr = Z_REFVAL_P(array_ref); + } + } else { + array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } + if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { + if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { + if (array_ptr == array_ref) { + ZVAL_NEW_REF(array_ref, array_ref); + array_ptr = Z_REFVAL_P(array_ref); } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } while (0); - } + Z_ADDREF_P(array_ref); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); + } else { + array_ref = EX_VAR(opline->result.var); + ZVAL_NEW_REF(array_ref, array_ptr); + array_ptr = Z_REFVAL_P(array_ref); + } + if (IS_TMP_VAR == IS_CONST) { + ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr))); + } else { + SEPARATE_ARRAY(array_ptr); + } + Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0); - if (IS_TMP_VAR == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_TMP_VAR & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } + ZEND_VM_NEXT_OPCODE(); + } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { + if (!Z_OBJCE_P(array_ptr)->get_iterator) { + zend_object *zobj = Z_OBJ_P(array_ptr); + HashTable *properties; + if (UNEXPECTED(zend_object_is_lazy(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (UNEXPECTED(EG(exception))) { + UNDEF_RESULT(); + + + HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - HANDLE_EXCEPTION(); - } + } + if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { + if (array_ptr == array_ref) { + ZVAL_NEW_REF(array_ref, array_ref); + array_ptr = Z_REFVAL_P(array_ref); } - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + Z_ADDREF_P(array_ref); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); + } else { + array_ptr = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(array_ptr, array_ref); + } + if (Z_OBJ_P(array_ptr)->properties + && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(Z_OBJ_P(array_ptr)->properties); } - zend_invalid_method_call(object, function_name); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties); } - } while (0); - } - - called_scope = obj->ce; - if (IS_TMP_VAR == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; + properties = Z_OBJPROP_P(array_ptr); + if (zend_hash_num_elements(properties) == 0) { + Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1; - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - } - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_TMP_VAR == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - } - } - if (IS_TMP_VAR != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } + Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0); - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); if (UNEXPECTED(EG(exception))) { HANDLE_EXCEPTION(); + } else if (is_empty) { + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else { + ZEND_VM_NEXT_OPCODE(); } } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_TMP_VAR == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } else { + zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } +} - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting)) + && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) { + EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var)); + } ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *value; + zend_reference *ref = NULL; + bool ret; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -case_true: - ZEND_VM_SMART_BRANCH_TRUE(); - } else { -case_false: - ZEND_VM_SMART_BRANCH_FALSE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -case_double: - if (d1 == d2) { - goto case_true; - } else { - goto case_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto case_double; + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) { + if (IS_TMP_VAR == IS_VAR) { + ref = Z_REF_P(value); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if (result) { - goto case_true; - } else { - goto case_false; + value = Z_REFVAL_P(value); + } + + ret = i_zend_is_true(value); + + if (UNEXPECTED(EG(exception))) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + + if (ret) { + zval *result = EX_VAR(opline->result.var); + + ZVAL_COPY_VALUE(result, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_TMP_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } else if (IS_TMP_VAR == IS_VAR && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); } } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); } - ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COALESCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *expr_ptr, new_expr; + zval *value; + zend_reference *ref = NULL; SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && - UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { - expr_ptr = zend_get_bad_ptr(); - if (Z_ISREF_P(expr_ptr)) { - Z_ADDREF_P(expr_ptr); - } else { - ZVAL_MAKE_REF_EX(expr_ptr, 2); + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { + if (IS_TMP_VAR & IS_VAR) { + ref = Z_REF_P(value); + } + value = Z_REFVAL_P(value); + } + + if (Z_TYPE_P(value) > IS_NULL) { + zval *result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_TMP_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } else if ((IS_TMP_VAR & IS_VAR) && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + if ((IS_TMP_VAR & IS_VAR) && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMP_NULL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val, *result; + + val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_P(val) > IS_NULL) { + do { + if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) { + val = Z_REFVAL_P(val); + if (Z_TYPE_P(val) <= IS_NULL) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + break; + } + } + ZEND_VM_NEXT_OPCODE(); + } while (0); + } + + result = EX_VAR(opline->result.var); + uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK; + if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { + ZVAL_NULL(result); + if (IS_TMP_VAR == IS_CV + && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF) + && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0 + ) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { + ZVAL_FALSE(result); + } else { + ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); + ZVAL_TRUE(result); + } + + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *result = EX_VAR(opline->result.var); + + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(result); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_TMP_VAR == IS_CV) { + ZVAL_COPY_DEREF(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(result, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { + Z_ADDREF_P(result); + } + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 + USE_OPLINE +#endif + + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + if (IS_CONST == IS_UNUSED) { + ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 + USE_OPLINE +#endif + + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + /* Behave like FETCH_OBJ_W */ + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_string **rope; + zval *var; + + /* op1 and result are the same */ + rope = (zend_string**)EX_VAR(opline->op1.var); + if (IS_CONST == IS_CONST) { + var = RT_CONSTANT(opline, opline->op2); + rope[opline->extended_value] = Z_STR_P(var); + if (UNEXPECTED(Z_REFCOUNTED_P(var))) { + Z_ADDREF_P(var); + } + } else { + var = RT_CONSTANT(opline, opline->op2); + if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { + if (IS_CONST == IS_CV) { + rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); + } else { + rope[opline->extended_value] = Z_STR_P(var); + } + } else { + SAVE_OPLINE(); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + } + rope[opline->extended_value] = zval_get_string_func(var); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_string **rope; + zval *var, *ret; + uint32_t i; + + rope = (zend_string**)EX_VAR(opline->op1.var); + if (IS_CONST == IS_CONST) { + var = RT_CONSTANT(opline, opline->op2); + rope[opline->extended_value] = Z_STR_P(var); + if (UNEXPECTED(Z_REFCOUNTED_P(var))) { + Z_ADDREF_P(var); + } + } else { + var = RT_CONSTANT(opline, opline->op2); + if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { + if (IS_CONST == IS_CV) { + rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); + } else { + rope[opline->extended_value] = Z_STR_P(var); + } + } else { + SAVE_OPLINE(); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + } + rope[opline->extended_value] = zval_get_string_func(var); + + + if (UNEXPECTED(EG(exception))) { + for (i = 0; i <= opline->extended_value; i++) { + zend_string_release_ex(rope[i], 0); + } + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } + } + + size_t len = 0; + uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES; + for (i = 0; i <= opline->extended_value; i++) { + flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]); + len += ZSTR_LEN(rope[i]); + } + ret = EX_VAR(opline->result.var); + ZVAL_STR(ret, zend_string_alloc(len, 0)); + GC_ADD_FLAGS(Z_STR_P(ret), flags); + + char *target = Z_STRVAL_P(ret); + for (i = 0; i <= opline->extended_value; i++) { + memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i])); + target += ZSTR_LEN(rope[i]); + zend_string_release_ex(rope[i], 0); + } + *target = '\0'; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value, *arg; + uint32_t arg_num; + + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { + if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_val_by_ref; + } + } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_val_by_ref:; + ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg)); + } + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr_ptr, new_expr; + + SAVE_OPLINE(); + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = zend_get_bad_ptr(); + if (Z_ISREF_P(expr_ptr)) { + Z_ADDREF_P(expr_ptr); + } else { + ZVAL_MAKE_REF_EX(expr_ptr, 2); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); } else { @@ -20866,15 +21374,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE } } - if (IS_TMP_VAR != IS_UNUSED) { - zval *offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if (IS_CONST != IS_UNUSED) { + zval *offset = RT_CONSTANT(opline, opline->op2); zend_string *str; zend_ulong hval; add_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if (IS_CONST != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index; } @@ -20885,7 +21393,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE hval = Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto add_again; } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { @@ -20918,7 +21426,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -20926,7 +21434,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE zend_illegal_array_offset_access(offset); zval_ptr_dtor_nogc(expr_ptr); } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + } else { if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { zend_cannot_add_element(); @@ -20936,7 +21445,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -20951,176 +21460,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SP if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { zend_hash_real_init_mixed(Z_ARRVAL_P(array)); } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { ZVAL_ARR(array, zend_new_array(0)); ZEND_VM_NEXT_OPCODE(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container; - bool result; - zend_ulong hval; - zval *offset; - - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - HashTable *ht; - zval *value; - zend_string *str; - -isset_dim_obj_array: - ht = Z_ARRVAL_P(container); -isset_again: - if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_prop; - } - } - value = zend_hash_find_ex(ht, str, IS_TMP_VAR == IS_CONST); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_prop: - value = zend_hash_index_find(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { - offset = Z_REFVAL_P(offset); - goto isset_again; - } else { - value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); - if (UNEXPECTED(EG(exception))) { - result = 0; - goto isset_dim_obj_exit; - } - } - - if (!(opline->extended_value & ZEND_ISEMPTY)) { - /* > IS_NULL means not IS_UNDEF and not IS_NULL */ - result = value != NULL && Z_TYPE_P(value) > IS_NULL && - (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); - - if (IS_TMP_VAR & (IS_CONST|IS_CV)) { - /* avoid exception check */ - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 0); - } - } else { - result = (value == NULL || !i_zend_is_true(value)); - } - goto isset_dim_obj_exit; - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto isset_dim_obj_array; - } - } - - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { - offset++; - } - if (!(opline->extended_value & ZEND_ISEMPTY)) { - result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); - } else { - result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); - } - -isset_dim_obj_exit: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container; - int result; - zval *offset; - zend_string *name, *tmp_name; - - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; - } - } else { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; - } - } - - if (IS_TMP_VAR == IS_CONST) { - name = Z_STR_P(offset); - } else { - name = zval_try_get_tmp_string(offset, &tmp_name); - if (UNEXPECTED(!name)) { - result = 0; - goto isset_object_finish; - } - } - - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); - } - -isset_object_finish: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - - zval *key, *subject; - HashTable *ht; - bool result; - - SAVE_OPLINE(); - - key = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - subject = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { -array_key_exists_array: - ht = Z_ARRVAL_P(subject); - result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); - } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { - subject = Z_REFVAL_P(subject); - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { - goto array_key_exists_array; - } - } - zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); - result = 0; - } - - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -21207,13 +21554,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TM } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if (IS_CONST != IS_UNUSED) { + zval *key = RT_CONSTANT(opline, opline->op2); + if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (Z_TYPE(generator->key) == IS_LONG && Z_LVAL(generator->key) > generator->largest_used_integer_key @@ -21242,186 +21589,521 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TM ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *expr; - bool result; - - SAVE_OPLINE(); - expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + zval *op1; + HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); + zval *result; -try_instanceof: - if (Z_TYPE_P(expr) == IS_OBJECT) { - zend_class_entry *ce; + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST); + if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + ZEND_VM_SMART_BRANCH(result, 0); + } - if (IS_VAR == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); - if (UNEXPECTED(ce == NULL)) { - ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); - if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); - } - } - } else if (IS_VAR == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op2.num); - if (UNEXPECTED(ce == NULL)) { + if (opline->extended_value) { + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + ZEND_VM_SMART_BRANCH(result, 0); + } + SAVE_OPLINE(); + if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find(ht, Z_STR_P(op1)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } + } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + } else if (Z_TYPE_P(op1) <= IS_FALSE) { + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); } - } else { - ce = Z_CE_P(EX_VAR(opline->op2.var)); } - result = ce && instanceof_function(Z_OBJCE_P(expr), ce); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { - expr = Z_REFVAL_P(expr); - goto try_instanceof; + result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); + ZEND_VM_SMART_BRANCH(result, 0); } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); + zend_string *key; + zval key_tmp; + + if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find(ht, Z_STR_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } } - result = 0; + + SAVE_OPLINE(); + ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) { + ZVAL_STR(&key_tmp, key); + if (zend_compare(op1, &key_tmp) == 0) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(1, 1); + } + } ZEND_HASH_FOREACH_END(); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_SMART_BRANCH(0, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV_EX zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ZEND_OPCODE_HANDLER_ARGS_EX int type) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { +#if 0 USE_OPLINE - zval *varname; - zval *retval; - zend_string *name, *tmp_name; - HashTable *target_symbol_table; - - SAVE_OPLINE(); - varname = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); +#endif - if (IS_TMP_VAR == IS_CONST) { - name = Z_STR_P(varname); - } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { - name = Z_STR_P(varname); - tmp_name = NULL; + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - name = zval_try_get_tmp_string(varname, &tmp_name); - if (UNEXPECTED(!name)) { - if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 + USE_OPLINE +#endif + + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + /* Behave like FETCH_OBJ_W */ + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } + ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +} - target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); - retval = zend_hash_find_ex(target_symbol_table, name, IS_TMP_VAR == IS_CONST); - if (retval == NULL) { - if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) { -fetch_this: - zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); - } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_string **rope; + zval *var; + + /* op1 and result are the same */ + rope = (zend_string**)EX_VAR(opline->op1.var); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + rope[opline->extended_value] = Z_STR_P(var); + if (UNEXPECTED(Z_REFCOUNTED_P(var))) { + Z_ADDREF_P(var); } - if (type == BP_VAR_W) { - retval = zend_hash_add_new(target_symbol_table, name, &EG(uninitialized_zval)); - } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) { - retval = &EG(uninitialized_zval); - } else { - if (IS_TMP_VAR == IS_CV) { - /* Keep name alive in case an error handler tries to free it. */ - zend_string_addref(name); - } - zend_error_unchecked(E_WARNING, "Undefined %svariable $%S", - (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name); - if (type == BP_VAR_RW && !EG(exception)) { - retval = zend_hash_update(target_symbol_table, name, &EG(uninitialized_zval)); + } else { + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); } else { - retval = &EG(uninitialized_zval); + rope[opline->extended_value] = Z_STR_P(var); } - if (IS_TMP_VAR == IS_CV) { - zend_string_release(name); + } else { + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); } + rope[opline->extended_value] = zval_get_string_func(var); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - /* GLOBAL or $$name variable may be an INDIRECT pointer to CV */ - } else if (Z_TYPE_P(retval) == IS_INDIRECT) { - retval = Z_INDIRECT_P(retval); - if (Z_TYPE_P(retval) == IS_UNDEF) { - if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) { - goto fetch_this; - } - if (type == BP_VAR_W) { - ZVAL_NULL(retval); - } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) { - retval = &EG(uninitialized_zval); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_string **rope; + zval *var, *ret; + uint32_t i; + + rope = (zend_string**)EX_VAR(opline->op1.var); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + rope[opline->extended_value] = Z_STR_P(var); + if (UNEXPECTED(Z_REFCOUNTED_P(var))) { + Z_ADDREF_P(var); + } + } else { + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); } else { - zend_error_unchecked(E_WARNING, "Undefined %svariable $%S", - (opline->extended_value & ZEND_FETCH_GLOBAL ? "global " : ""), name); - if (type == BP_VAR_RW && !EG(exception)) { - ZVAL_NULL(retval); - } else { - retval = &EG(uninitialized_zval); + rope[opline->extended_value] = Z_STR_P(var); + } + } else { + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + } + rope[opline->extended_value] = zval_get_string_func(var); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (UNEXPECTED(EG(exception))) { + for (i = 0; i <= opline->extended_value; i++) { + zend_string_release_ex(rope[i], 0); } + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } } } - if (!(opline->extended_value & ZEND_FETCH_GLOBAL_LOCK)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + size_t len = 0; + uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES; + for (i = 0; i <= opline->extended_value; i++) { + flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]); + len += ZSTR_LEN(rope[i]); } + ret = EX_VAR(opline->result.var); + ZVAL_STR(ret, zend_string_alloc(len, 0)); + GC_ADD_FLAGS(Z_STR_P(ret), flags); - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); + char *target = Z_STRVAL_P(ret); + for (i = 0; i <= opline->extended_value; i++) { + memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i])); + target += ZSTR_LEN(rope[i]); + zend_string_release_ex(rope[i], 0); } + *target = '\0'; - ZEND_ASSERT(retval != NULL); - if (type == BP_VAR_R || type == BP_VAR_IS) { - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr_ptr, new_expr; + + SAVE_OPLINE(); + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = zend_get_bad_ptr(); + if (Z_ISREF_P(expr_ptr)) { + Z_ADDREF_P(expr_ptr); + } else { + ZVAL_MAKE_REF_EX(expr_ptr, 2); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); } else { - ZVAL_INDIRECT(EX_VAR(opline->result.var), retval); + expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_TMP_VAR) { + /* pass */ + } else if (IS_TMP_VAR == IS_CONST) { + Z_TRY_ADDREF_P(expr_ptr); + } else if (IS_TMP_VAR == IS_CV) { + ZVAL_DEREF(expr_ptr); + Z_TRY_ADDREF_P(expr_ptr); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(expr_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(expr_ptr); + + expr_ptr = Z_REFVAL_P(expr_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) { + Z_ADDREF_P(expr_ptr); + } + } + } + } + + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + zend_string *str; + zend_ulong hval; + +add_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index; + } + } +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index: + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + offset = Z_REFVAL_P(offset); + goto add_again; + } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { + zval tmp; + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_COPY(&tmp, expr_ptr); + } + zend_error(E_DEPRECATED, "Using null as an array offset is deprecated, use an empty string instead"); + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + /* A userland error handler can do funky things to the expression, so reset it */ + zval_ptr_dtor(expr_ptr); + ZVAL_COPY_VALUE(expr_ptr, &tmp); + } + if (UNEXPECTED(EG(exception))) { + zval_ptr_dtor_nogc(expr_ptr); + HANDLE_EXCEPTION(); + } + str = ZSTR_EMPTY_ALLOC(); + goto str_index; + } else if (Z_TYPE_P(offset) == IS_DOUBLE) { + hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + goto num_index; + } else if (Z_TYPE_P(offset) == IS_FALSE) { + hval = 0; + goto num_index; + } else if (Z_TYPE_P(offset) == IS_TRUE) { + hval = 1; + goto num_index; + } else if (Z_TYPE_P(offset) == IS_RESOURCE) { + zend_use_resource_as_offset(offset); + hval = Z_RES_HANDLE_P(offset); + goto num_index; + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + ZVAL_UNDEFINED_OP2(); + str = ZSTR_EMPTY_ALLOC(); + goto str_index; + } else { + zend_illegal_array_offset_access(offset); + zval_ptr_dtor_nogc(expr_ptr); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } else { + if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { + zend_cannot_add_element(); + zval_ptr_dtor_nogc(expr_ptr); + } } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R)); + zval *array; + uint32_t size; + USE_OPLINE + + SAVE_OPLINE(); + array = EX_VAR(opline->result.var); + if (IS_TMP_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + ZVAL_ARR(array, zend_new_array(size)); + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init_mixed(Z_ARRVAL_P(array)); + } + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + ZVAL_ARR(array, zend_new_array(0)); + ZEND_VM_NEXT_OPCODE(); + } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W)); + USE_OPLINE + + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + + SAVE_OPLINE(); + if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) { + ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + + /* Destroy the previously yielded value */ + zval_ptr_dtor(&generator->value); + + /* Destroy the previously yielded key */ + zval_ptr_dtor(&generator->key); + + /* Set the new yielded value */ + if (IS_TMP_VAR != IS_UNUSED) { + if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) { + /* Constants and temporary variables aren't yieldable by reference, + * but we still allow them with a notice. */ + if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) { + zval *value; + + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(&generator->value, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) { + Z_ADDREF(generator->value); + } + } + } else { + zval *value_ptr = zend_get_bad_ptr(); + + /* If a function call result is yielded and the function did + * not return by reference we throw a notice. */ + do { + if (IS_TMP_VAR == IS_VAR) { + ZEND_ASSERT(value_ptr != &EG(uninitialized_zval)); + if (opline->extended_value == ZEND_RETURNS_FUNCTION + && !Z_ISREF_P(value_ptr)) { + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + ZVAL_COPY(&generator->value, value_ptr); + break; + } + } + if (Z_ISREF_P(value_ptr)) { + Z_ADDREF_P(value_ptr); + } else { + ZVAL_MAKE_REF_EX(value_ptr, 2); + } + ZVAL_REF(&generator->value, Z_REF_P(value_ptr)); + } while (0); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } + } else { + zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + /* Consts, temporary variables and references need copying */ + if (IS_TMP_VAR == IS_CONST) { + ZVAL_COPY_VALUE(&generator->value, value); + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) { + Z_ADDREF(generator->value); + } + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { + ZVAL_COPY(&generator->value, Z_REFVAL_P(value)); + + + } else { + ZVAL_COPY_VALUE(&generator->value, value); + if (IS_TMP_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); + } + } + } + } else { + /* If no value was specified yield null */ + ZVAL_NULL(&generator->value); + } + + /* Set the new yielded key */ + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + key = Z_REFVAL_P(key); + } + ZVAL_COPY(&generator->key, key); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key + ) { + generator->largest_used_integer_key = Z_LVAL(generator->key); + } + } else { + /* If no key was specified we use auto-increment keys */ + generator->largest_used_integer_key++; + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + } + + if (RETURN_VALUE_USED(opline)) { + /* If the return value of yield is used set the send + * target and initialize it to NULL */ + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); + } else { + generator->send_target = NULL; + } + + /* The GOTO VM uses a local opline variable. We need to set the opline + * variable in execute_data so we don't resume at an old position. */ + SAVE_OPLINE(); + + ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW)); + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - int fetch_type = - (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ? - BP_VAR_W : BP_VAR_R; - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type)); + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET)); + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 @@ -21437,12 +22119,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_UNUSED == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_TMP_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -21721,97 +22397,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SP } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - bool result; - zval *varname; - zend_string *name, *tmp_name; - HashTable *target_symbol_table; - - SAVE_OPLINE(); - varname = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { - name = Z_STR_P(varname); - } else { - name = zval_get_tmp_string(varname, &tmp_name); - } - - target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); - value = zend_hash_find_ex(target_symbol_table, name, IS_TMP_VAR == IS_CONST); - - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - if (!value) { - result = (opline->extended_value & ZEND_ISEMPTY); - } else { - if (Z_TYPE_P(value) == IS_INDIRECT) { - value = Z_INDIRECT_P(value); - } - if (!(opline->extended_value & ZEND_ISEMPTY)) { - if (Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - } - result = Z_TYPE_P(value) > IS_NULL; - } else { - result = !i_zend_is_true(value); - } - } - - ZEND_VM_SMART_BRANCH(result, true); -} - -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *expr; - bool result; - - SAVE_OPLINE(); - expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - -try_instanceof: - if (Z_TYPE_P(expr) == IS_OBJECT) { - zend_class_entry *ce; - - if (IS_UNUSED == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); - if (UNEXPECTED(ce == NULL)) { - ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); - if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); - } - } - } else if (IS_UNUSED == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op2.num); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op2.var)); - } - result = ce && instanceof_function(Z_OBJCE_P(expr), ce); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { - expr = Z_REFVAL_P(expr); - goto try_instanceof; - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - result = 0; - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -21933,119 +22519,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TM ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COUNT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1; - zend_long count; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - while (1) { - if (Z_TYPE_P(op1) == IS_ARRAY) { - count = zend_hash_num_elements(Z_ARRVAL_P(op1)); - break; - } else if (Z_TYPE_P(op1) == IS_OBJECT) { - zend_object *zobj = Z_OBJ_P(op1); - - /* first, we check if the handler is defined */ - if (zobj->handlers->count_elements) { - if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) { - break; - } - if (UNEXPECTED(EG(exception))) { - count = 0; - break; - } - } - - /* if not and the object implements Countable we call its count() method */ - if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) { - zval retval; - - zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT)); - zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval); - count = zval_get_long(&retval); - zval_ptr_dtor(&retval); - break; - } - - /* If There's no handler and it doesn't implement Countable then emit a TypeError */ - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { - op1 = Z_REFVAL_P(op1); - continue; - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - count = 0; - zend_type_error("%s(): Argument #1 ($value) must be of type Countable|array, %s given", opline->extended_value ? "sizeof" : "count", zend_zval_value_name(op1)); - break; - } - - ZVAL_LONG(EX_VAR(opline->result.var), count); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC)); - ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { - SAVE_OPLINE(); - zend_array_destroy(ht); - if (EG(exception)) { - HANDLE_EXCEPTION(); - } - } - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GET_CLASS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - - if (IS_TMP_VAR == IS_UNUSED) { - SAVE_OPLINE(); - if (UNEXPECTED(!EX(func)->common.scope)) { - zend_throw_error(NULL, "get_class() without arguments must be called from within a class"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } else { - zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); - ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - ZEND_VM_NEXT_OPCODE(); - } - } else { - zval *op1; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - while (1) { - if (Z_TYPE_P(op1) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { - op1 = Z_REFVAL_P(op1); - continue; - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - } - break; - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -22064,114 +22537,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GET_TYPE_SPEC ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - div_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - pow_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = EX_VAR(opline->op2.var); - - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CV == IS_CONST || IS_CV == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); - - if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { - zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); - } - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } - ZEND_VM_NEXT_OPCODE(); - } else { - SAVE_OPLINE(); - - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - op1 = ZVAL_UNDEFINED_OP1(); - } - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - op2 = ZVAL_UNDEFINED_OP2(); - } - concat_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -22187,21 +22552,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_S ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - compare_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 @@ -22217,12 +22567,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_CV == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_TMP_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -22240,142 +22584,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - zend_string *op1_str, *op2_str, *str; - - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = EX_VAR(opline->op2.var); - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CV == IS_CONST || IS_CV == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); - - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } - ZEND_VM_NEXT_OPCODE(); - } - - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CONST) { - op1_str = Z_STR_P(op1); - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - op1_str = zend_string_copy(Z_STR_P(op1)); - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - op1_str = zval_get_string_func(op1); - } - if (IS_CV == IS_CONST) { - op2_str = Z_STR_P(op2); - } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - op2_str = zend_string_copy(Z_STR_P(op2)); - } else { - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - } - op2_str = zval_get_string_func(op2); - } - do { - if (IS_TMP_VAR != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CV == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { - GC_ADDREF(op2_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - zend_string_release_ex(op1_str, 0); - break; - } - } - if (IS_CV != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { - GC_ADDREF(op1_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - zend_string_release_ex(op2_str, 0); - break; - } - } - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - - ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR != IS_CONST) { - zend_string_release_ex(op1_str, 0); - } - if (IS_CV != IS_CONST) { - zend_string_release_ex(op2_str, 0); - } - } while (0); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -22473,269 +22685,57 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_END_SPEC ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; + zval *expr_ptr, new_expr; SAVE_OPLINE(); + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = zend_get_bad_ptr(); + if (Z_ISREF_P(expr_ptr)) { + Z_ADDREF_P(expr_ptr); + } else { + ZVAL_MAKE_REF_EX(expr_ptr, 2); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } else { + expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_TMP_VAR) { + /* pass */ + } else if (IS_TMP_VAR == IS_CONST) { + Z_TRY_ADDREF_P(expr_ptr); + } else if (IS_TMP_VAR == IS_CV) { + ZVAL_DEREF(expr_ptr); + Z_TRY_ADDREF_P(expr_ptr); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(expr_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(expr_ptr); - object = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - if (IS_CV != IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + expr_ptr = Z_REFVAL_P(expr_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) { + Z_ADDREF_P(expr_ptr); } } - zend_throw_error(NULL, "Method name must be a string"); - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } while (0); + } } - if (IS_TMP_VAR == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); + if (IS_CV != IS_UNUSED) { + zval *offset = EX_VAR(opline->op2.var); + zend_string *str; + zend_ulong hval; - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_TMP_VAR & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST) { - - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - zend_invalid_method_call(object, function_name); - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); - } - - - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - } - } - - if (IS_CV != IS_CONST) { - - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_TMP_VAR == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = EX_VAR(opline->op2.var); - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -case_true: - ZEND_VM_SMART_BRANCH_TRUE(); - } else { -case_false: - ZEND_VM_SMART_BRANCH_FALSE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -case_double: - if (d1 == d2) { - goto case_true; - } else { - goto case_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - - - if (result) { - goto case_true; - } else { - goto case_false; - } - } - } - ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *expr_ptr, new_expr; - - SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && - UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { - expr_ptr = zend_get_bad_ptr(); - if (Z_ISREF_P(expr_ptr)) { - Z_ADDREF_P(expr_ptr); - } else { - ZVAL_MAKE_REF_EX(expr_ptr, 2); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } else { - expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_TMP_VAR) { - /* pass */ - } else if (IS_TMP_VAR == IS_CONST) { - Z_TRY_ADDREF_P(expr_ptr); - } else if (IS_TMP_VAR == IS_CV) { - ZVAL_DEREF(expr_ptr); - Z_TRY_ADDREF_P(expr_ptr); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(expr_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(expr_ptr); - - expr_ptr = Z_REFVAL_P(expr_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - ZVAL_COPY_VALUE(&new_expr, expr_ptr); - expr_ptr = &new_expr; - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) { - Z_ADDREF_P(expr_ptr); - } - } - } - } - - if (IS_CV != IS_UNUSED) { - zval *offset = EX_VAR(opline->op2.var); - zend_string *str; - zend_ulong hval; - -add_again: - if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - if (IS_CV != IS_CONST) { - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index; +add_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CV != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index; } } str_index: @@ -22818,171 +22818,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SP } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container; - bool result; - zend_ulong hval; - zval *offset; - - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = EX_VAR(opline->op2.var); - - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - HashTable *ht; - zval *value; - zend_string *str; - -isset_dim_obj_array: - ht = Z_ARRVAL_P(container); -isset_again: - if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - if (IS_CV != IS_CONST) { - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_prop; - } - } - value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_prop: - value = zend_hash_index_find(ht, hval); - } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { - offset = Z_REFVAL_P(offset); - goto isset_again; - } else { - value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); - if (UNEXPECTED(EG(exception))) { - result = 0; - goto isset_dim_obj_exit; - } - } - - if (!(opline->extended_value & ZEND_ISEMPTY)) { - /* > IS_NULL means not IS_UNDEF and not IS_NULL */ - result = value != NULL && Z_TYPE_P(value) > IS_NULL && - (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); - - if (IS_TMP_VAR & (IS_CONST|IS_CV)) { - /* avoid exception check */ - - - ZEND_VM_SMART_BRANCH(result, 0); - } - } else { - result = (value == NULL || !i_zend_is_true(value)); - } - goto isset_dim_obj_exit; - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto isset_dim_obj_array; - } - } - - if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { - offset++; - } - if (!(opline->extended_value & ZEND_ISEMPTY)) { - result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); - } else { - result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); - } - -isset_dim_obj_exit: - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container; - int result; - zval *offset; - zend_string *name, *tmp_name; - - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - - if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; - } - } else { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; - } - } - - if (IS_CV == IS_CONST) { - name = Z_STR_P(offset); - } else { - name = zval_try_get_tmp_string(offset, &tmp_name); - if (UNEXPECTED(!name)) { - result = 0; - goto isset_object_finish; - } - } - - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - - if (IS_CV != IS_CONST) { - zend_tmp_string_release(tmp_name); - } - -isset_object_finish: - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - - zval *key, *subject; - HashTable *ht; - bool result; - - SAVE_OPLINE(); - - key = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - subject = EX_VAR(opline->op2.var); - - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { -array_key_exists_array: - ht = Z_ARRVAL_P(subject); - result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); - } else { - if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { - subject = Z_REFVAL_P(subject); - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { - goto array_key_exists_array; - } - } - zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); - result = 0; - } - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -23372,6 +23207,88 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_P ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + + retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + + + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + SAVE_OPLINE(); + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + + + + + + ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -23437,8 +23354,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RETURN_BY_REF - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -23488,66 +23403,213 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GENERATOR_RET ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *array_ptr, *array_ref; + zval *arg, *param; SAVE_OPLINE(); - if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (Z_ISREF_P(array_ref)) { - array_ptr = Z_REFVAL_P(array_ref); - } + arg = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); } else { - array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY(param, arg); } - if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { - if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - if (array_ptr == array_ref) { - ZVAL_NEW_REF(array_ref, array_ref); - array_ptr = Z_REFVAL_P(array_ref); - } - Z_ADDREF_P(array_ref); - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); - } else { - array_ref = EX_VAR(opline->result.var); - ZVAL_NEW_REF(array_ref, array_ptr); - array_ptr = Z_REFVAL_P(array_ref); - } - if (IS_VAR == IS_CONST) { - ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr))); - } else { - SEPARATE_ARRAY(array_ptr); - } - Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); - } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { - if (!Z_OBJCE_P(array_ptr)->get_iterator) { - zend_object *zobj = Z_OBJ_P(array_ptr); - HashTable *properties; - if (UNEXPECTED(zend_object_is_lazy(zobj))) { - zobj = zend_lazy_object_init(zobj); - if (UNEXPECTED(EG(exception))) { - UNDEF_RESULT(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + switch (opline->extended_value) { + case IS_LONG: + ZVAL_LONG(result, zval_get_long(expr)); + break; + case IS_DOUBLE: + ZVAL_DOUBLE(result, zval_get_double(expr)); + break; + case IS_STRING: + ZVAL_STR(result, zval_get_string(expr)); + break; + default: + ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead"); + if (IS_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); } - if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { - if (array_ptr == array_ref) { - ZVAL_NEW_REF(array_ref, array_ref); - array_ptr = Z_REFVAL_P(array_ref); + /* If value is already of correct type, return it directly */ + if (Z_TYPE_P(expr) == opline->extended_value) { + ZVAL_COPY_VALUE(result, expr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); } - Z_ADDREF_P(array_ref); - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); - } else { - array_ptr = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(array_ptr, array_ref); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (opline->extended_value == IS_ARRAY) { + zend_cast_zval_to_array(result, expr, IS_VAR); + } else { + ZEND_ASSERT(opline->extended_value == IS_OBJECT); + zend_cast_zval_to_object(result, expr, IS_VAR); + } + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *array_ptr, *result; + + SAVE_OPLINE(); + + array_ptr = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { + result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, array_ptr); + if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(array_ptr); + } + Z_FE_POS_P(result) = 0; + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { + zend_object *zobj = Z_OBJ_P(array_ptr); + if (!zobj->ce->get_iterator) { + if (UNEXPECTED(zend_object_is_lazy(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (UNEXPECTED(EG(exception))) { + UNDEF_RESULT(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + HashTable *properties = zobj->properties; + if (properties) { + if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(properties); + } + properties = zobj->properties = zend_array_dup(properties); + } + } else { + properties = zobj->handlers->get_properties(zobj); + } + + result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, array_ptr); + if (IS_VAR != IS_TMP_VAR) { + Z_ADDREF_P(array_ptr); + } + + if (zend_hash_num_elements(properties) == 0) { + Z_FE_ITER_P(result) = (uint32_t) -1; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + } + + Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } else if (is_empty) { + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else { + ZEND_VM_NEXT_OPCODE(); + } + } + } else { + zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + } +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *array_ptr, *array_ref; + + SAVE_OPLINE(); + + if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { + array_ref = array_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_ISREF_P(array_ref)) { + array_ptr = Z_REFVAL_P(array_ref); + } + } else { + array_ref = array_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + } + + if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { + if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { + if (array_ptr == array_ref) { + ZVAL_NEW_REF(array_ref, array_ref); + array_ptr = Z_REFVAL_P(array_ref); + } + Z_ADDREF_P(array_ref); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); + } else { + array_ref = EX_VAR(opline->result.var); + ZVAL_NEW_REF(array_ref, array_ptr); + array_ptr = Z_REFVAL_P(array_ref); + } + if (IS_VAR == IS_CONST) { + ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr))); + } else { + SEPARATE_ARRAY(array_ptr); + } + Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { + if (!Z_OBJCE_P(array_ptr)->get_iterator) { + zend_object *zobj = Z_OBJ_P(array_ptr); + HashTable *properties; + if (UNEXPECTED(zend_object_is_lazy(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (UNEXPECTED(EG(exception))) { + UNDEF_RESULT(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + if (IS_VAR == IS_VAR || IS_VAR == IS_CV) { + if (array_ptr == array_ref) { + ZVAL_NEW_REF(array_ref, array_ref); + array_ptr = Z_REFVAL_P(array_ref); + } + Z_ADDREF_P(array_ref); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); + } else { + array_ptr = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(array_ptr, array_ref); } if (Z_OBJ_P(array_ptr)->properties && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) { @@ -23587,6 +23649,86 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_RESET_RW_S } } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *array; + zval *value; + uint32_t value_type; + HashTable *fe_ht; + HashPosition pos; + + array = EX_VAR(opline->op1.var); + if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) { + ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + fe_ht = Z_ARRVAL_P(array); + pos = Z_FE_POS_P(array); + if (HT_IS_PACKED(fe_ht)) { + value = fe_ht->arPacked + pos; + while (1) { + if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { + /* reached end of iteration */ + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } + value_type = Z_TYPE_INFO_P(value); + ZEND_ASSERT(value_type != IS_INDIRECT); + if (EXPECTED(value_type != IS_UNDEF)) { + break; + } + pos++; + value++; + } + Z_FE_POS_P(array) = pos + 1; + if (RETURN_VALUE_USED(opline)) { + ZVAL_LONG(EX_VAR(opline->result.var), pos); + } + } else { + Bucket *p; + + p = fe_ht->arData + pos; + while (1) { + if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { + /* reached end of iteration */ + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } + pos++; + value = &p->val; + value_type = Z_TYPE_INFO_P(value); + ZEND_ASSERT(value_type != IS_INDIRECT); + if (EXPECTED(value_type != IS_UNDEF)) { + break; + } + p++; + } + Z_FE_POS_P(array) = pos; + if (RETURN_VALUE_USED(opline)) { + if (!p->key) { + ZVAL_LONG(EX_VAR(opline->result.var), p->h); + } else { + ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key); + } + } + } + if (EXPECTED(opline->op2_type == IS_CV)) { + zval *variable_ptr = EX_VAR(opline->op2.var); + SAVE_OPLINE(); + zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + zval *res = EX_VAR(opline->op2.var); + zend_refcounted *gc = Z_COUNTED_P(value); + + ZVAL_COPY_VALUE_EX(res, value, gc, value_type); + if (Z_TYPE_INFO_REFCOUNTED(value_type)) { + GC_ADDREF(gc); + } + ZEND_VM_NEXT_OPCODE(); + } +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -23790,6 +23932,138 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FE_FETCH_RW_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zend_reference *ref = NULL; + bool ret; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + ref = Z_REF_P(value); + } + value = Z_REFVAL_P(value); + } + + ret = i_zend_is_true(value); + + if (UNEXPECTED(EG(exception))) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + + if (ret) { + zval *result = EX_VAR(opline->result.var); + + ZVAL_COPY_VALUE(result, value); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } else if (IS_VAR == IS_VAR && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zend_reference *ref = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { + if (IS_VAR & IS_VAR) { + ref = Z_REF_P(value); + } + value = Z_REFVAL_P(value); + } + + if (Z_TYPE_P(value) > IS_NULL) { + zval *result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, value); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } else if ((IS_VAR & IS_VAR) && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + if ((IS_VAR & IS_VAR) && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val, *result; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_P(val) > IS_NULL) { + do { + if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) { + val = Z_REFVAL_P(val); + if (Z_TYPE_P(val) <= IS_NULL) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + break; + } + } + ZEND_VM_NEXT_OPCODE(); + } while (0); + } + + result = EX_VAR(opline->result.var); + uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK; + if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { + ZVAL_NULL(result); + if (IS_VAR == IS_CV + && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF) + && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0 + ) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { + ZVAL_FALSE(result); + } else { + ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); + ZVAL_TRUE(result); + } + + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -23845,6 +24119,53 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_S ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -23938,7 +24259,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -24248,12 +24569,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_CONST == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -24327,12 +24642,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -24416,7 +24725,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -24534,7 +24843,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -24573,7 +24882,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -24689,7 +24998,162 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CONST == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + } else { + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CONST != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -24728,7 +25192,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -24846,7 +25310,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -25159,6 +25623,160 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CONST == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = RT_CONSTANT(opline, opline->op2); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = RT_CONSTANT(opline, opline->op2); + if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CONST == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = RT_CONSTANT(opline, opline->op2); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = RT_CONSTANT(opline, opline->op2); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = RT_CONSTANT(opline, 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) { + + + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -25412,7 +26030,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -25451,7 +26069,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -26427,6 +27045,78 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_VA ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1; + HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); + zval *result; + + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_VAR == IS_CONST); + if (IS_VAR & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + ZEND_VM_SMART_BRANCH(result, 0); + } + + if (opline->extended_value) { + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + ZEND_VM_SMART_BRANCH(result, 0); + } + SAVE_OPLINE(); + if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find(ht, Z_STR_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } + } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + } else if (Z_TYPE_P(op1) <= IS_FALSE) { + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); + ZEND_VM_SMART_BRANCH(result, 0); + } else { + zend_string *key; + zval key_tmp; + + if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find(ht, Z_STR_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } + } + + SAVE_OPLINE(); + ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) { + ZVAL_STR(&key_tmp, key); + if (zend_compare(op1, &key_tmp) == 0) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(1, 1); + } + } ZEND_HASH_FOREACH_END(); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(0, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -26560,7 +27250,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_C ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -26575,7 +27265,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); @@ -26596,7 +27286,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP assign_op_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -26605,7 +27295,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -26640,7 +27330,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP } else { zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -26652,8 +27342,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *var_ptr; @@ -26668,15 +27358,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP SEPARATE_ARRAY(container); ht = Z_ARRVAL_P(container); assign_dim_op_new_array: - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_UNUSED) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC); } else { var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC); @@ -26689,7 +27379,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); do { - if (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { zend_reference *ref = Z_REF_P(var_ptr); var_ptr = Z_REFVAL_P(var_ptr); if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { @@ -26715,8 +27405,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { zend_object *obj = Z_OBJ_P(container); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC); @@ -26739,7 +27429,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP } goto assign_dim_op_new_array; } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -26754,14 +27444,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *var_ptr; zval *value; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); do { @@ -26785,7 +27475,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -26799,7 +27489,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -26818,7 +27508,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S pre_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -26827,7 +27517,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -26841,7 +27531,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -26851,7 +27541,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -26865,7 +27555,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -26884,7 +27574,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ post_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -26893,7 +27583,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { ZVAL_NULL(EX_VAR(opline->result.var)); @@ -26905,7 +27595,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -26915,14 +27605,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - zend_fetch_dimension_address_W(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_W(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -26930,14 +27620,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_W_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - zend_fetch_dimension_address_RW(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_RW(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -26945,7 +27635,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_RW_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -26955,29 +27645,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -26985,7 +27669,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_UNS ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; @@ -26993,11 +27677,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_S SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); zend_fetch_property_address( - result, container, IS_VAR, property, IS_TMP_VAR, - ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), + result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { @@ -27006,16 +27690,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_VAR, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -27023,7 +27707,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -27034,28 +27718,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *property, *result; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_VAR, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -27063,30 +27741,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNS ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_LIST_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *dim; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_VAR == IS_VAR && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT && UNEXPECTED(!Z_ISREF_P(container)) ) { zend_error(E_NOTICE, "Attempting to set reference to non referenceable value"); - zend_fetch_dimension_address_LIST_r(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_LIST_r(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } else { - zend_fetch_dimension_address_W(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_W(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -27103,14 +27781,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -27124,7 +27802,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -27136,7 +27814,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -27204,9 +27882,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -27219,9 +27897,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -27241,8 +27919,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -27259,14 +27937,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -27280,7 +27958,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -27292,7 +27970,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -27360,9 +28038,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -27374,9 +28052,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -27395,8 +28073,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -27406,21 +28084,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -27434,11 +28112,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: - value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } @@ -27446,7 +28124,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -27471,13 +28149,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { - if (IS_CV == IS_CONST) { + if (IS_VAR == IS_CONST) { if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } - } else if (IS_CV != IS_TMP_VAR) { + } else if (IS_VAR != IS_TMP_VAR) { if (Z_ISREF_P(value)) { - if (IS_CV == IS_VAR) { + if (IS_VAR == IS_VAR) { zend_reference *ref = Z_REF_P(value); if (GC_DELREF(ref) == 0) { ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); @@ -27491,7 +28169,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP value = Z_REFVAL_P(value); Z_TRY_ADDREF_P(value); } - } else if (IS_CV == IS_CV) { + } else if (IS_VAR == IS_CV) { Z_TRY_ADDREF_P(value); } } @@ -27514,24 +28192,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); goto exit_assign_obj; } } - if (IS_CV == IS_CV || IS_CV == IS_VAR) { + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -27539,8 +28216,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); exit_assign_obj: if (garbage) { GC_DTOR_NO_REF(garbage); @@ -27551,165 +28227,164 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *object_ptr, *orig_object_ptr; - zval *value; - zval *variable_ptr; - zval *dim; + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; zend_refcounted *garbage = NULL; SAVE_OPLINE(); - orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { -try_assign_dim_array: - SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { - value = RT_CONSTANT((opline+1), (opline+1)->op1); - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - HashTable *ht = Z_ARRVAL_P(object_ptr); - if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { - GC_ADDREF(ht); + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } } - value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { - zend_array_destroy(ht); - goto assign_dim_error; + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } } - } - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - ZVAL_DEREF(value); - } - value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); - if (UNEXPECTED(value == NULL)) { - zend_cannot_add_element(); - goto assign_dim_error; - } else if (IS_CONST == IS_CV) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); } - } else if (IS_CONST == IS_VAR) { - zval *free_op_data = EX_VAR((opline+1)->op1.var); - if (Z_ISREF_P(free_op_data)) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; } - zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(value))) { - Z_ADDREF_P(value); + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_CV != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_CV == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_CV == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; } - } - } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { - variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { - variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); - } - if (UNEXPECTED(variable_ptr == NULL)) { - goto assign_dim_error; + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ } - value = RT_CONSTANT((opline+1), (opline+1)->op1); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (garbage) { - GC_DTOR_NO_REF(garbage); } + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - if (EXPECTED(Z_ISREF_P(object_ptr))) { - object_ptr = Z_REFVAL_P(object_ptr); - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { - goto try_assign_dim_array; - } - } - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_object *obj = Z_OBJ_P(object_ptr); - - GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { - dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; - } - - value = RT_CONSTANT((opline+1), (opline+1)->op1); - if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { - value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - } else if (IS_CONST & (IS_CV|IS_VAR)) { - ZVAL_DEREF(value); - } - - zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); - - - if (UNEXPECTED(GC_DELREF(obj) == 0)) { - zend_objects_store_del(obj); - } - } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { - zend_use_new_element_for_string(); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { - UNDEF_RESULT(); - } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - value = RT_CONSTANT((opline+1), (opline+1)->op1); - zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - + UNDEF_RESULT(); + goto exit_assign_obj; + } + } - } - } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { - if (Z_ISREF_P(orig_object_ptr) - && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) - && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); + } + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - UNDEF_RESULT(); - } else { - HashTable *ht = zend_new_array(8); - uint8_t old_type = Z_TYPE_P(object_ptr); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - ZVAL_ARR(object_ptr, ht); - if (UNEXPECTED(old_type == IS_FALSE)) { - GC_ADDREF(ht); - zend_false_to_array_deprecated(); - if (UNEXPECTED(GC_DELREF(ht) == 0)) { - zend_array_destroy(ht); - goto assign_dim_error; - } - } - goto try_assign_dim_array; - } - } else { - zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); -assign_dim_error: +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); - } - } - } - if (IS_TMP_VAR != IS_UNUSED) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - /* assign_dim has two opcodes! */ + /* assign_obj has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -27724,9 +28399,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + value = RT_CONSTANT((opline+1), (opline+1)->op1); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { GC_ADDREF(ht); @@ -27737,18 +28412,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP goto assign_dim_error; } } - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { ZVAL_DEREF(value); } value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); if (UNEXPECTED(value == NULL)) { zend_cannot_add_element(); goto assign_dim_error; - } else if (IS_TMP_VAR == IS_CV) { + } else if (IS_CONST == IS_CV) { if (Z_REFCOUNTED_P(value)) { Z_ADDREF_P(value); } - } else if (IS_TMP_VAR == IS_VAR) { + } else if (IS_CONST == IS_VAR) { zval *free_op_data = EX_VAR((opline+1)->op1.var); if (Z_ISREF_P(free_op_data)) { if (Z_REFCOUNTED_P(value)) { @@ -27756,14 +28431,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_TMP_VAR == IS_CONST) { + } else if (IS_CONST == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -27771,8 +28446,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (UNEXPECTED(variable_ptr == NULL)) { goto assign_dim_error; } - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + value = RT_CONSTANT((opline+1), (opline+1)->op1); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); @@ -27791,43 +28466,46 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = RT_CONSTANT((opline+1), (opline+1)->op1); + if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) { + } else if (IS_CONST & (IS_CV|IS_VAR)) { ZVAL_DEREF(value); } zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + + UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = RT_CONSTANT((opline+1), (opline+1)->op1); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + + } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + UNDEF_RESULT(); } else { HashTable *ht = zend_new_array(8); @@ -27846,15 +28524,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); 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_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -27862,7 +28541,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -27877,9 +28556,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { - value = EX_VAR((opline+1)->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { GC_ADDREF(ht); @@ -27890,18 +28569,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP goto assign_dim_error; } } - if (IS_CV == IS_CV || IS_CV == IS_VAR) { + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { ZVAL_DEREF(value); } value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); if (UNEXPECTED(value == NULL)) { zend_cannot_add_element(); goto assign_dim_error; - } else if (IS_CV == IS_CV) { + } else if (IS_TMP_VAR == IS_CV) { if (Z_REFCOUNTED_P(value)) { Z_ADDREF_P(value); } - } else if (IS_CV == IS_VAR) { + } else if (IS_TMP_VAR == IS_VAR) { zval *free_op_data = EX_VAR((opline+1)->op1.var); if (Z_ISREF_P(free_op_data)) { if (Z_REFCOUNTED_P(value)) { @@ -27909,14 +28588,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_CV == IS_CONST) { + } else if (IS_TMP_VAR == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -27924,8 +28603,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (UNEXPECTED(variable_ptr == NULL)) { goto assign_dim_error; } - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); @@ -27944,46 +28623,43 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } - value = EX_VAR((opline+1)->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - } else if (IS_CV & (IS_CV|IS_VAR)) { + } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) { ZVAL_DEREF(value); } zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(GC_DELREF(obj) == 0)) { zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - value = EX_VAR((opline+1)->op1.var); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { HashTable *ht = zend_new_array(8); @@ -28002,16 +28678,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); 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_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -28019,65 +28694,317 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *object_ptr, *orig_object_ptr; zval *value; zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if (0 || UNEXPECTED(0)) { - zend_refcounted *garbage = NULL; + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(0)) { + 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) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { GC_DTOR_NO_REF(garbage); } } else { - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); +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(EX_VAR(opline->op2.var)); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - /* zend_assign_to_variable() always takes care of op2, never free it! */ - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *object_ptr, *orig_object_ptr; zval *value; zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if (0 || UNEXPECTED(1)) { - zend_refcounted *garbage = NULL; + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(1)) { + 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) { + value = EX_VAR((opline+1)->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_CV == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { GC_DTOR_NO_REF(garbage); } } else { - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = EX_VAR((opline+1)->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_CV & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_use_new_element_for_string(); + + + UNDEF_RESULT(); + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = EX_VAR((opline+1)->op1.var); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + + + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); +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(EX_VAR(opline->op2.var)); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - /* zend_assign_to_variable() always takes care of op2, never free it! */ - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -28085,26 +29012,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_VAR == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_VAR, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -28113,8 +29040,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -28122,26 +29049,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_VAR == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_VAR, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -28151,8 +29078,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -28172,7 +29099,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { CACHE_PTR(opline->result.num, ce); } } @@ -28187,24 +29114,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M } if (IS_VAR == IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { /* nothing to do */ } else if (IS_VAR != IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == ce)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_TMP_VAR != IS_UNUSED) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if (IS_TMP_VAR & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -28220,7 +29147,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name)); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { @@ -28229,7 +29156,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) { CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); @@ -28237,7 +29164,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } } else { @@ -28285,7 +29212,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *expr_ptr, new_expr; @@ -28325,15 +29252,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE } } - if (IS_TMP_VAR != IS_UNUSED) { - zval *offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_string *str; zend_ulong hval; add_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index; } @@ -28344,7 +29271,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE hval = Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto add_again; } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { @@ -28377,7 +29304,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -28395,7 +29322,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -28410,14 +29337,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SP if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { zend_hash_real_init_mixed(Z_ARRVAL_P(array)); } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { ZVAL_ARR(array, zend_new_array(0)); ZEND_VM_NEXT_OPCODE(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -28427,7 +29354,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -28439,7 +29366,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE offset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { key = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(key, hval)) { goto num_index_dim; } @@ -28451,7 +29378,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE hval = Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { @@ -28480,7 +29407,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); goto str_index_dim; @@ -28497,11 +29424,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { container = ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = ZVAL_UNDEFINED_OP2(); } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset); @@ -28519,7 +29446,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -28528,7 +29455,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -28545,7 +29472,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE break; } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -28553,8 +29480,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE break; } } - Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -28564,7 +29491,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -28650,9 +29577,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_VA } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -28685,6 +29612,210 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_VA ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (0 || UNEXPECTED(0)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (0 || UNEXPECTED(1)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (0 || UNEXPECTED(0)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (0 || UNEXPECTED(1)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -28872,12 +30003,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_UNUSED == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -29194,6 +30319,160 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_UNUSED == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = NULL; + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = NULL; + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_UNUSED == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = NULL; + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = NULL; + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_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) { + + + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -29991,17 +31270,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NEW_SPEC_VAR_ zend_function *constructor; zend_class_entry *ce; zend_execute_data *call; + uint32_t cache_slot; + bool has_generic_args = false; SAVE_OPLINE(); if (IS_VAR == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); + cache_slot = opline->op2.num & 0x7FFFFFFF; + has_generic_args = (opline->op2.num & 0x80000000) != 0; + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - CACHE_PTR(opline->op2.num, ce); + CACHE_PTR(cache_slot, ce); } } else if (IS_VAR == IS_UNUSED) { ce = zend_fetch_class(NULL, opline->op1.num); @@ -30019,6 +31302,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NEW_SPEC_VAR_ HANDLE_EXCEPTION(); } + /* Bind generic type arguments to the newly created object */ + if (has_generic_args) { + /* Generic args literal is stored at op1.constant + 2 + * (after class name + lowercase class name) */ + zval *generic_args_zv = RT_CONSTANT(opline, opline->op1) + 2; + zend_generic_args *compiled_args = (zend_generic_args *) Z_PTR_P(generic_args_zv); + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(compiled_args); + /* Verify type arguments satisfy constraints (e.g., T: Countable) */ + if (ce->generic_params_info) { + zend_verify_generic_args(ce->generic_params_info, Z_OBJ_P(result)->generic_args); + } + } else if (ce->bound_generic_args) { + /* Inherit bound generic args from class (e.g., IntList extends Collection) */ + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(ce->bound_generic_args); + } + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next @@ -30355,6 +31654,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_MAKE_REF_SPEC ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1; + zend_string *type; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + type = zend_zval_get_legacy_type(op1); + if (EXPECTED(type)) { + ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type); + } else { + ZVAL_STRING(EX_VAR(opline->result.var), "unknown type"); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -30377,6 +31694,21 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_S ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -30470,7 +31802,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -30780,12 +32112,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_CV == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -30859,12 +32185,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -30948,7 +32268,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -31066,7 +32386,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -31105,7 +32425,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -31221,8 +32541,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -31232,7 +32552,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { @@ -31260,11 +32580,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: - value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } @@ -31297,13 +32617,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { - if (IS_CV == IS_CONST) { + if (IS_VAR == IS_CONST) { if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } - } else if (IS_CV != IS_TMP_VAR) { + } else if (IS_VAR != IS_TMP_VAR) { if (Z_ISREF_P(value)) { - if (IS_CV == IS_VAR) { + if (IS_VAR == IS_VAR) { zend_reference *ref = Z_REF_P(value); if (GC_DELREF(ref) == 0) { ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); @@ -31317,7 +32637,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP value = Z_REFVAL_P(value); Z_TRY_ADDREF_P(value); } - } else if (IS_CV == IS_CV) { + } else if (IS_VAR == IS_CV) { Z_TRY_ADDREF_P(value); } } @@ -31344,14 +32664,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } else { name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); goto exit_assign_obj; } } - if (IS_CV == IS_CV || IS_CV == IS_VAR) { + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(value); } @@ -31365,8 +32684,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); } - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); exit_assign_obj: if (garbage) { GC_DTOR_NO_REF(garbage); @@ -31378,166 +32696,165 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *object_ptr, *orig_object_ptr; - zval *value; - zval *variable_ptr; - zval *dim; + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; zend_refcounted *garbage = NULL; SAVE_OPLINE(); - orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { -try_assign_dim_array: - SEPARATE_ARRAY(object_ptr); - if (IS_CV == IS_UNUSED) { - value = RT_CONSTANT((opline+1), (opline+1)->op1); - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - HashTable *ht = Z_ARRVAL_P(object_ptr); - if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { - GC_ADDREF(ht); + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CV == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } } - value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { - zend_array_destroy(ht); - goto assign_dim_error; + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } } - } - if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { - ZVAL_DEREF(value); - } - value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); - if (UNEXPECTED(value == NULL)) { - zend_cannot_add_element(); - goto assign_dim_error; - } else if (IS_CONST == IS_CV) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); } - } else if (IS_CONST == IS_VAR) { - zval *free_op_data = EX_VAR((opline+1)->op1.var); - if (Z_ISREF_P(free_op_data)) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; } - zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(value))) { - Z_ADDREF_P(value); + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_CV != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_CV == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_CV == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; } - } - } else { - dim = EX_VAR(opline->op2.var); - if (IS_CV == IS_CONST) { - variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { - variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); - } - if (UNEXPECTED(variable_ptr == NULL)) { - goto assign_dim_error; + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ } - value = RT_CONSTANT((opline+1), (opline+1)->op1); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); - } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (garbage) { - GC_DTOR_NO_REF(garbage); } + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); } else { - if (EXPECTED(Z_ISREF_P(object_ptr))) { - object_ptr = Z_REFVAL_P(object_ptr); - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { - goto try_assign_dim_array; - } - } - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_object *obj = Z_OBJ_P(object_ptr); - - GC_ADDREF(obj); - dim = EX_VAR(opline->op2.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { - dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; - } - - value = RT_CONSTANT((opline+1), (opline+1)->op1); - if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { - value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - } else if (IS_CONST & (IS_CV|IS_VAR)) { - ZVAL_DEREF(value); - } - - zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); - - - if (UNEXPECTED(GC_DELREF(obj) == 0)) { - zend_objects_store_del(obj); - } - } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_CV == IS_UNUSED) { - zend_use_new_element_for_string(); - + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { - UNDEF_RESULT(); - } else { - dim = EX_VAR(opline->op2.var); - value = RT_CONSTANT((opline+1), (opline+1)->op1); - zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } - } - } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { - if (Z_ISREF_P(orig_object_ptr) - && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) - && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); + } + value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - UNDEF_RESULT(); - } else { - HashTable *ht = zend_new_array(8); - uint8_t old_type = Z_TYPE_P(object_ptr); + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - ZVAL_ARR(object_ptr, ht); - if (UNEXPECTED(old_type == IS_FALSE)) { - GC_ADDREF(ht); - zend_false_to_array_deprecated(); - if (UNEXPECTED(GC_DELREF(ht) == 0)) { - zend_array_destroy(ht); - goto assign_dim_error; - } - } - goto try_assign_dim_array; - } - } else { - zend_use_scalar_as_array(); - dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); -assign_dim_error: +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_NULL(EX_VAR(opline->result.var)); - } - } +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); } - if (IS_CV != IS_UNUSED) { - } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - /* assign_dim has two opcodes! */ + /* assign_obj has two opcodes! */ ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -31553,8 +32870,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP try_assign_dim_array: SEPARATE_ARRAY(object_ptr); if (IS_CV == IS_UNUSED) { - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + value = RT_CONSTANT((opline+1), (opline+1)->op1); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { GC_ADDREF(ht); @@ -31565,18 +32882,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP goto assign_dim_error; } } - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { ZVAL_DEREF(value); } value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); if (UNEXPECTED(value == NULL)) { zend_cannot_add_element(); goto assign_dim_error; - } else if (IS_TMP_VAR == IS_CV) { + } else if (IS_CONST == IS_CV) { if (Z_REFCOUNTED_P(value)) { Z_ADDREF_P(value); } - } else if (IS_TMP_VAR == IS_VAR) { + } else if (IS_CONST == IS_VAR) { zval *free_op_data = EX_VAR((opline+1)->op1.var); if (Z_ISREF_P(free_op_data)) { if (Z_REFCOUNTED_P(value)) { @@ -31584,7 +32901,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_TMP_VAR == IS_CONST) { + } else if (IS_CONST == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } @@ -31599,8 +32916,166 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (UNEXPECTED(variable_ptr == NULL)) { goto assign_dim_error; } - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + value = RT_CONSTANT((opline+1), (opline+1)->op1); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = RT_CONSTANT((opline+1), (opline+1)->op1); + if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_CONST & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CV == IS_UNUSED) { + zend_use_new_element_for_string(); + + + UNDEF_RESULT(); + } else { + dim = EX_VAR(opline->op2.var); + value = RT_CONSTANT((opline+1), (opline+1)->op1); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + + + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + + + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); +assign_dim_error: + + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } + } + } + if (IS_CV != IS_UNUSED) { + + + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CV == IS_UNUSED) { + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_TMP_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_TMP_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); @@ -31691,6 +33166,160 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CV == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CV == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = EX_VAR(opline->op2.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); +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) { + + + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -31983,7 +33612,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -32022,7 +33651,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -32924,7 +34553,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -33065,15 +34694,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV SAVE_OPLINE(); container = &EX(This); - if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_UNUSED & IS_CV) && Z_ISREF_P(container)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -33286,8 +34911,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ SAVE_OPLINE(); container = &EX(This); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -33416,12 +35039,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_UNUSED == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -33482,7 +35099,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -33601,7 +35218,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -33640,7 +35257,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -33757,7 +35374,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = &EX(This); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CONST == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + } else { + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CONST != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -33796,7 +35569,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -33915,7 +35688,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -33953,7 +35726,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -33992,7 +35765,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -34939,7 +36712,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_C ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -34954,7 +36727,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP SAVE_OPLINE(); object = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); @@ -34975,7 +36748,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP assign_op_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -34984,7 +36757,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -35019,7 +36792,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP } else { zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -35032,8 +36805,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -35047,7 +36820,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S SAVE_OPLINE(); object = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -35066,7 +36839,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S pre_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -35075,7 +36848,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -35089,7 +36862,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -35100,7 +36873,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -35114,7 +36887,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ SAVE_OPLINE(); object = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -35133,7 +36906,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ post_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -35142,7 +36915,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { ZVAL_NULL(EX_VAR(opline->result.var)); @@ -35154,7 +36927,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -35165,7 +36938,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -35173,15 +36946,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S SAVE_OPLINE(); container = &EX(This); - if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_UNUSED & IS_CV) && Z_ISREF_P(container)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -35190,7 +36959,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_wrong_property_read(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); ZVAL_NULL(EX_VAR(opline->result.var)); goto fetch_obj_r_finish; } while (0); @@ -35202,7 +36971,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -35262,7 +37031,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -35295,9 +37064,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -35321,7 +37090,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S } #endif - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -35340,7 +37109,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; @@ -35348,11 +37117,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_S SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); zend_fetch_property_address( - result, container, IS_UNUSED, property, IS_TMP_VAR, - ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), + result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_UNUSED == IS_VAR) { @@ -35361,16 +37130,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_UNUSED, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_UNUSED == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -35378,7 +37147,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -35386,8 +37155,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ SAVE_OPLINE(); container = &EX(This); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -35398,7 +37165,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ break; } } - if (IS_TMP_VAR == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(EX_VAR(opline->result.var)); @@ -35412,7 +37179,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -35439,7 +37206,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -35472,9 +37239,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -35483,7 +37250,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -35502,7 +37269,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -35513,28 +37280,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_UNUSED == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *property, *result; SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_UNUSED, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_UNUSED == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -35542,7 +37303,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNS ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -35559,14 +37320,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -35580,7 +37341,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -35592,7 +37353,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -35660,9 +37421,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -35675,9 +37436,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -35698,8 +37459,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -35716,14 +37477,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -35737,7 +37498,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -35749,7 +37510,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -35817,9 +37578,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -35831,9 +37592,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -35853,8 +37614,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = &EX(This); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -35871,14 +37787,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -35892,7 +37808,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -35904,7 +37820,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -35972,9 +37888,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -35987,9 +37903,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -36010,8 +37926,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -36019,26 +37935,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_UNUSED == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_UNUSED, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } @@ -36047,8 +37963,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -36056,26 +37972,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_UNUSED == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_UNUSED, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } @@ -36085,8 +38001,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_INIT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_string **rope; @@ -36094,23 +38010,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_INIT_SPE /* Compiler allocates the necessary number of zval slots to keep the rope */ rope = (zend_string**)EX_VAR(opline->result.var); - if (IS_TMP_VAR == IS_CONST) { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); rope[0] = Z_STR_P(var); if (UNEXPECTED(Z_REFCOUNTED_P(var))) { Z_ADDREF_P(var); } } else { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { rope[0] = zend_string_copy(Z_STR_P(var)); } else { rope[0] = Z_STR_P(var); } } else { SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } rope[0] = zval_get_string_func(var); @@ -36121,36 +38037,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_INIT_SPE ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *class_name; USE_OPLINE SAVE_OPLINE(); - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else if (IS_TMP_VAR == IS_CONST) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_class_entry *ce = CACHED_PTR(opline->extended_value); if (UNEXPECTED(ce == NULL)) { - class_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num); CACHE_PTR(opline->extended_value, ce); } Z_CE_P(EX_VAR(opline->result.var)) = ce; } else { - class_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); try_class_name: if (Z_TYPE_P(class_name) == IS_OBJECT) { Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name); } else if (Z_TYPE_P(class_name) == IS_STRING) { Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) { class_name = Z_REFVAL_P(class_name); goto try_class_name; } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -36164,7 +38080,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_CLASS_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -36179,19 +38095,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C object = &EX(This); - if (IS_TMP_VAR != IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST && + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { @@ -36233,14 +38149,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { object = ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } HANDLE_EXCEPTION(); } } - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -36253,18 +38169,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C called_scope = obj->ce; - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { zend_object *orig_obj = obj; - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); @@ -36275,7 +38191,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C } HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(obj == orig_obj)) { CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); @@ -36291,7 +38207,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -36322,7 +38238,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -36342,7 +38258,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { CACHE_PTR(opline->result.num, ce); } } @@ -36357,24 +38273,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M } if (IS_UNUSED == IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { /* nothing to do */ } else if (IS_UNUSED != IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == ce)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_TMP_VAR != IS_UNUSED) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if (IS_TMP_VAR & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -36390,7 +38306,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name)); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { @@ -36399,7 +38315,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) { CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); @@ -36407,7 +38323,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } } else { @@ -36455,7 +38371,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_STATIC_M ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -36477,7 +38393,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SP } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -36486,7 +38402,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE SAVE_OPLINE(); container = &EX(This); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -36503,7 +38419,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE break; } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -36511,8 +38427,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE break; } } - Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -36523,7 +38439,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -36533,7 +38449,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY SAVE_OPLINE(); container = &EX(This); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -36549,7 +38465,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -36561,9 +38477,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY result = (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -36574,7 +38490,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -36661,9 +38577,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_UN } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -37036,17 +38952,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NEW_SPEC_UNUS zend_function *constructor; zend_class_entry *ce; zend_execute_data *call; + uint32_t cache_slot; + bool has_generic_args = false; SAVE_OPLINE(); if (IS_UNUSED == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); + cache_slot = opline->op2.num & 0x7FFFFFFF; + has_generic_args = (opline->op2.num & 0x80000000) != 0; + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - CACHE_PTR(opline->op2.num, ce); + CACHE_PTR(cache_slot, ce); } } else if (IS_UNUSED == IS_UNUSED) { ce = zend_fetch_class(NULL, opline->op1.num); @@ -37064,6 +38984,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NEW_SPEC_UNUS HANDLE_EXCEPTION(); } + /* Bind generic type arguments to the newly created object */ + if (has_generic_args) { + /* Generic args literal is stored at op1.constant + 2 + * (after class name + lowercase class name) */ + zval *generic_args_zv = RT_CONSTANT(opline, opline->op1) + 2; + zend_generic_args *compiled_args = (zend_generic_args *) Z_PTR_P(generic_args_zv); + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(compiled_args); + /* Verify type arguments satisfy constraints (e.g., T: Countable) */ + if (ce->generic_params_info) { + zend_verify_generic_args(ce->generic_params_info, Z_OBJ_P(result)->generic_args); + } + } else if (ce->bound_generic_args) { + /* Inherit bound generic args from class (e.g., IntList extends Collection) */ + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(ce->bound_generic_args); + } + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next @@ -37429,27 +39365,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CALLABLE_CONV USE_OPLINE zend_execute_data *call = EX(call); - if (opline->extended_value != (uint32_t)-1) { - zend_object *closure = CACHED_PTR(opline->extended_value); - if (closure) { - ZVAL_OBJ_COPY(EX_VAR(opline->result.var), closure); - } else { - /* Rotate the key for better hash distribution. */ - const int shift = sizeof(size_t) == 4 ? 6 : 7; - zend_ulong key = (zend_ulong)(uintptr_t)call->func; - key = (key >> shift) | (key << ((sizeof(key) * 8) - shift)); - zval *closure_zv = zend_hash_index_lookup(&EG(callable_convert_cache), key); - if (Z_TYPE_P(closure_zv) == IS_NULL) { - zend_closure_from_frame(closure_zv, call); - } - ZEND_ASSERT(Z_TYPE_P(closure_zv) == IS_OBJECT); - closure = Z_OBJ_P(closure_zv); - ZVAL_OBJ_COPY(EX_VAR(opline->result.var), closure); - CACHE_PTR(opline->extended_value, closure); - } - } else { - zend_closure_from_frame(EX_VAR(opline->result.var), call); - } + zend_closure_from_frame(EX_VAR(opline->result.var), call); if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) { OBJ_RELEASE(Z_OBJ(call->This)); @@ -37477,7 +39393,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FRAMELESS_ICA #endif { zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline); - function(result); + function(EX_VAR(opline->result.var)); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -37497,7 +39413,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FRAMELESS_ICA #endif { zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline); - function(result); + function(EX_VAR(opline->result.var)); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -37596,7 +39512,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -37737,15 +39653,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S SAVE_OPLINE(); container = &EX(This); - if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_UNUSED & IS_CV) && Z_ISREF_P(container)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -37953,8 +39865,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ SAVE_OPLINE(); container = &EX(This); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -38083,12 +39993,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_UNUSED == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -38149,7 +40053,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -38268,7 +40172,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -38307,7 +40211,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -38424,7 +40328,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = &EX(This); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CV == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -38463,7 +40523,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -38582,7 +40642,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -38620,7 +40680,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -38659,7 +40719,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -39863,8 +41923,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_RETURN_BY_REF - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_TAIL_CALL(zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } @@ -39943,8 +42001,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_THROW_SPEC_CV } } while (0); + zend_exception_save(); Z_TRY_ADDREF_P(value); zend_throw_exception_object(value); + zend_exception_restore(); HANDLE_EXCEPTION(); @@ -41695,7 +43755,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -41969,17 +44029,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } dim = RT_CONSTANT(opline, opline->op2); if (IS_CV != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CV == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -42042,8 +44098,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_ SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC); @@ -42067,12 +44121,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_CONST == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CV & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -42101,15 +44149,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CV & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -42322,8 +44366,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -42452,12 +44494,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CV == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -42518,7 +44554,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -42637,7 +44673,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -42676,7 +44712,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -42793,7 +44829,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = EX_VAR(opline->op1.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CONST == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + } else { + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CONST != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -42832,7 +45024,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -42951,7 +45143,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -43266,6 +45458,161 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CONST == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = RT_CONSTANT(opline, opline->op2); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = RT_CONSTANT(opline, opline->op2); + if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CONST == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = RT_CONSTANT(opline, opline->op2); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = RT_CONSTANT(opline, opline->op2); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = RT_CONSTANT(opline, 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); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -43522,7 +45869,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -43561,7 +45908,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -44461,13 +46808,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SP try_instanceof: if (Z_TYPE_P(expr) == IS_OBJECT) { zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; if (IS_CONST == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); + CACHE_PTR(cache_slot, ce); } } } else if (IS_CONST == IS_UNUSED) { @@ -44482,6 +46830,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SP ce = Z_CE_P(EX_VAR(opline->op2.var)); } result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_CONST == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { expr = Z_REFVAL_P(expr); goto try_instanceof; @@ -44922,14 +47285,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_F ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); div_function(EX_VAR(opline->result.var), op1, op2); @@ -44937,14 +47300,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_DIV_SPEC_CV_T ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); pow_function(EX_VAR(opline->result.var), op1, op2); @@ -44952,23 +47315,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POW_SPEC_CV_T ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); @@ -44976,13 +47339,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CV == IS_CONST || IS_CV == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else if (IS_CV != IS_CONST && IS_CV != IS_CV && @@ -44996,7 +47359,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -45008,7 +47371,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } @@ -45019,7 +47382,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { op1 = ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { op2 = ZVAL_UNDEFINED_OP2(); } concat_function(EX_VAR(opline->result.var), op1, op2); @@ -45030,56 +47393,140 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_CONCAT_SPEC_C } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; - bool result; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_identical_function(op1, op2); - + double d1, d2; - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + op1 = EX_VAR(opline->op1.var); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; - bool result; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_not_identical_function(op1, op2); - + double d1, d2; - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); + op1 = EX_VAR(opline->op1.var); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); } else { is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); @@ -45107,7 +47554,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (result) { @@ -45120,131 +47567,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; - } - } - } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; - - op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; - } - } - } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; - - op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -45281,7 +47612,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_ if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (!result) { @@ -45294,15 +47625,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_ ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -45339,7 +47670,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_ if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (!result) { @@ -45352,15 +47683,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_ ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -45397,7 +47728,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_ if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (!result) { @@ -45410,14 +47741,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_EQUAL_ ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); compare_function(EX_VAR(opline->result.var), op1, op2); @@ -45425,14 +47756,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_SPACESHIP_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); boolean_xor_function(EX_VAR(opline->result.var), op1, op2); @@ -45440,7 +47771,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_BOOL_XOR_SPEC ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -45455,7 +47786,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP SAVE_OPLINE(); object = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); @@ -45476,7 +47807,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP assign_op_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -45485,7 +47816,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -45520,7 +47851,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP } else { zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -45533,8 +47864,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *var_ptr; @@ -45549,15 +47880,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP SEPARATE_ARRAY(container); ht = Z_ARRVAL_P(container); assign_dim_op_new_array: - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_UNUSED) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC); } else { var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC); @@ -45570,7 +47901,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); do { - if (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { zend_reference *ref = Z_REF_P(var_ptr); var_ptr = Z_REFVAL_P(var_ptr); if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { @@ -45596,8 +47927,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { zend_object *obj = Z_OBJ_P(container); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC); @@ -45620,7 +47951,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP } goto assign_dim_op_new_array; } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -45636,14 +47967,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *var_ptr; zval *value; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC); do { @@ -45668,7 +47999,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OP_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -45682,7 +48013,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S SAVE_OPLINE(); object = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -45701,7 +48032,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S pre_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -45710,7 +48041,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -45724,7 +48055,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -45735,7 +48066,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_PRE_INC_OBJ_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -45749,7 +48080,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ SAVE_OPLINE(); object = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -45768,7 +48099,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ post_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -45777,7 +48108,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { ZVAL_NULL(EX_VAR(opline->result.var)); @@ -45789,7 +48120,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -45800,24 +48131,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_POST_INC_OBJ_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *dim, *value; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_CV != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_TMP_VAR, BP_VAR_R EXECUTE_DATA_CC); + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CV == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -45826,13 +48153,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S } } else { fetch_dim_r_slow: - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } } else { - zend_fetch_dimension_address_read_R(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -45840,14 +48167,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - zend_fetch_dimension_address_W(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_W(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -45855,14 +48182,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_W_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - zend_fetch_dimension_address_RW(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_RW(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -45870,23 +48197,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_RW_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -45896,29 +48221,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CV & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -45926,7 +48245,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_UNS ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -45934,15 +48253,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CV & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -45951,7 +48266,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_wrong_property_read(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); ZVAL_NULL(EX_VAR(opline->result.var)); goto fetch_obj_r_finish; } while (0); @@ -45963,7 +48278,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -46023,7 +48338,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -46056,9 +48371,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -46082,7 +48397,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S } #endif - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -46101,7 +48416,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; @@ -46109,11 +48424,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_S SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); zend_fetch_property_address( - result, container, IS_CV, property, IS_TMP_VAR, - ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), + result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { @@ -46122,16 +48437,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_W_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_CV, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -46139,7 +48454,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_RW_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -46147,8 +48462,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -46159,7 +48472,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ break; } } - if (IS_TMP_VAR == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(EX_VAR(opline->result.var)); @@ -46173,7 +48486,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -46200,7 +48513,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -46233,9 +48546,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -46244,7 +48557,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -46263,7 +48576,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -46274,28 +48587,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CV == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *property, *result; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_CV, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -46303,7 +48610,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_UNS ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -46320,14 +48627,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -46341,7 +48648,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -46353,7 +48660,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -46421,9 +48728,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -46436,9 +48743,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -46459,8 +48766,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -46477,14 +48784,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -46498,7 +48805,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -46510,7 +48817,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -46578,9 +48885,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -46592,9 +48899,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -46614,8 +48921,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = EX_VAR(opline->op1.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -46632,14 +49094,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -46653,7 +49115,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -46665,7 +49127,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -46733,9 +49195,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -46748,9 +49210,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -46771,8 +49233,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -46787,7 +49249,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { value = RT_CONSTANT((opline+1), (opline+1)->op1); if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); @@ -46825,8 +49287,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -46854,10 +49316,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } @@ -46875,13 +49337,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value = RT_CONSTANT((opline+1), (opline+1)->op1); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); @@ -46891,7 +49353,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); UNDEF_RESULT(); @@ -46912,7 +49374,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -46921,7 +49383,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } } - if (IS_TMP_VAR != IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -46930,7 +49392,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -46945,7 +49407,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); @@ -46983,8 +49445,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -47012,10 +49474,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } @@ -47033,12 +49495,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); @@ -47047,7 +49509,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { @@ -47067,7 +49529,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -47075,7 +49537,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } } - if (IS_TMP_VAR != IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -47084,7 +49546,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -47099,9 +49561,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { - value = EX_VAR((opline+1)->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { GC_ADDREF(ht); @@ -47112,18 +49574,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP goto assign_dim_error; } } - if (IS_CV == IS_CV || IS_CV == IS_VAR) { + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(value); } value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); if (UNEXPECTED(value == NULL)) { zend_cannot_add_element(); goto assign_dim_error; - } else if (IS_CV == IS_CV) { + } else if (IS_VAR == IS_CV) { if (Z_REFCOUNTED_P(value)) { Z_ADDREF_P(value); } - } else if (IS_CV == IS_VAR) { + } else if (IS_VAR == IS_VAR) { zval *free_op_data = EX_VAR((opline+1)->op1.var); if (Z_ISREF_P(free_op_data)) { if (Z_REFCOUNTED_P(value)) { @@ -47131,14 +49593,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_CV == IS_CONST) { + } else if (IS_VAR == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -47146,8 +49608,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP if (UNEXPECTED(variable_ptr == NULL)) { goto assign_dim_error; } - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); @@ -47166,46 +49628,43 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } - value = EX_VAR((opline+1)->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - } else if (IS_CV & (IS_CV|IS_VAR)) { + } else if (IS_VAR & (IS_CV|IS_VAR)) { ZVAL_DEREF(value); } zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(GC_DELREF(obj) == 0)) { zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - value = EX_VAR((opline+1)->op1.var); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { HashTable *ht = zend_new_array(8); @@ -47224,16 +49683,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); 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_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -47242,67 +49700,165 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *object_ptr, *orig_object_ptr; zval *value; zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - variable_ptr = EX_VAR(opline->op1.var); - - if (0 || UNEXPECTED(0)) { - zend_refcounted *garbage = NULL; + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(0)) { + 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) { + value = EX_VAR((opline+1)->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_CV == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { GC_DTOR_NO_REF(garbage); } } else { - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); - } + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + GC_ADDREF(obj); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } - /* zend_assign_to_variable() always takes care of op2, never free it! */ + value = EX_VAR((opline+1)->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_CV & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - zval *variable_ptr; - SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - variable_ptr = EX_VAR(opline->op1.var); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_use_new_element_for_string(); - if (0 || UNEXPECTED(1)) { - zend_refcounted *garbage = NULL; - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(1)) { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (garbage) { - GC_DTOR_NO_REF(garbage); + UNDEF_RESULT(); + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = EX_VAR((opline+1)->op1.var); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + + + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); +assign_dim_error: + + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } } - } else { - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } - /* zend_assign_to_variable() always takes care of op2, never free it! */ - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -47310,26 +49866,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_CV == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_CV, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } @@ -47338,8 +49894,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -47347,26 +49903,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_CV == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_CV, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } @@ -47376,8 +49932,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; @@ -47385,16 +49941,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); @@ -47402,13 +49958,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CV == IS_CONST || IS_CV == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else if (IS_CV != IS_CONST && IS_CV != IS_CV && @@ -47419,7 +49975,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -47431,7 +49987,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } @@ -47449,12 +50005,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S } op1_str = zval_get_string_func(op1); } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { op2_str = Z_STR_P(op2); } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { op2_str = zend_string_copy(Z_STR_P(op2)); } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } op2_str = zval_get_string_func(op2); @@ -47462,7 +50018,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S do { if (IS_CV != IS_CONST) { if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { GC_ADDREF(op2_str); } @@ -47472,7 +50028,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S break; } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CV == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { @@ -47493,7 +50049,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S if (IS_CV != IS_CONST) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_string_release_ex(op2_str, 0); } } while (0); @@ -47503,7 +50059,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_S ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -47518,19 +50074,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C object = EX_VAR(opline->op1.var); - if (IS_TMP_VAR != IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST && + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { @@ -47572,14 +50128,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { object = ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } HANDLE_EXCEPTION(); } } - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -47592,18 +50148,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C called_scope = obj->ce; - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { zend_object *orig_obj = obj; - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); @@ -47614,7 +50170,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C } HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(obj == orig_obj)) { CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); @@ -47630,7 +50186,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -47661,7 +50217,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_METHOD_C ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *expr_ptr, new_expr; @@ -47702,15 +50258,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE } } - if (IS_TMP_VAR != IS_UNUSED) { - zval *offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_string *str; zend_ulong hval; add_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index; } @@ -47721,7 +50277,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE hval = Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto add_again; } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { @@ -47754,7 +50310,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -47772,7 +50328,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ADD_ARRAY_ELE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -47787,14 +50343,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INIT_ARRAY_SP if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { zend_hash_real_init_mixed(Z_ARRVAL_P(array)); } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { ZVAL_ARR(array, zend_new_array(0)); ZEND_VM_NEXT_OPCODE(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -47804,7 +50360,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -47816,7 +50372,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE offset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { key = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(key, hval)) { goto num_index_dim; } @@ -47828,7 +50384,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE hval = Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { @@ -47857,7 +50413,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); goto str_index_dim; @@ -47874,11 +50430,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { container = ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = ZVAL_UNDEFINED_OP2(); } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset); @@ -47897,7 +50453,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_DIM_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -47906,7 +50462,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -47923,7 +50479,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE break; } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -47931,8 +50487,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE break; } } - Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -47943,7 +50499,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_OBJ_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -47953,7 +50509,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { HashTable *ht; @@ -47965,17 +50521,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY isset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index_prop; } } - value = zend_hash_find_ex(ht, str, IS_TMP_VAR == IS_CONST); + value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { hval = Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { offset = Z_REFVAL_P(offset); goto isset_again; } else { @@ -48007,7 +50563,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY } } - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } if (!(opline->extended_value & ZEND_ISEMPTY)) { @@ -48023,7 +50579,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -48033,7 +50589,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -48049,7 +50605,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -48061,9 +50617,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY result = (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -48074,7 +50630,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -48085,14 +50641,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXI SAVE_OPLINE(); key = EX_VAR(opline->op1.var); - subject = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { array_key_exists_array: ht = Z_ARRVAL_P(subject); result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { subject = Z_REFVAL_P(subject); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { goto array_key_exists_array; @@ -48108,7 +50664,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ARRAY_KEY_EXI ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -48195,9 +50751,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CV } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -48230,6 +50786,190 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_YIELD_SPEC_CV ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + + if (0 || UNEXPECTED(0)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + + + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + + if (0 || UNEXPECTED(1)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + + + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + + if (0 || UNEXPECTED(0)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + + + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + + if (0 || UNEXPECTED(1)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + + + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -48282,13 +51022,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SP try_instanceof: if (Z_TYPE_P(expr) == IS_OBJECT) { zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; if (IS_VAR == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); + CACHE_PTR(cache_slot, ce); } } } else if (IS_VAR == IS_UNUSED) { @@ -48303,6 +51044,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SP ce = Z_CE_P(EX_VAR(opline->op2.var)); } result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_VAR == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { expr = Z_REFVAL_P(expr); goto try_instanceof; @@ -48555,7 +51311,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_IS_SPEC ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_CV_UNUSED(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -48603,12 +51359,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_UNUSED == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CV & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_NULL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -48927,6 +51677,161 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_UNUSED == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = NULL; + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = NULL; + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_UNUSED == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = NULL; + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = NULL; + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_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); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -49557,7 +52462,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_UNSET_VAR_SPE ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -49646,7 +52551,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ISSET_ISEMPTY ZEND_VM_SMART_BRANCH(result, true); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -49659,13 +52564,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SP try_instanceof: if (Z_TYPE_P(expr) == IS_OBJECT) { zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; if (IS_UNUSED == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); + CACHE_PTR(cache_slot, ce); } } } else if (IS_UNUSED == IS_UNUSED) { @@ -49680,6 +52586,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_INSTANCEOF_SP ce = Z_CE_P(EX_VAR(opline->op2.var)); } result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_UNUSED == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { expr = Z_REFVAL_P(expr); goto try_instanceof; @@ -50637,7 +53558,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_OP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -50911,17 +53832,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_R_S SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } dim = EX_VAR(opline->op2.var); if (IS_CV != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CV == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -50984,8 +53901,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_IS_ SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC); @@ -51009,12 +53924,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_DIM_FUN if (IS_CV == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CV & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -51043,15 +53952,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_R_S SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CV & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -51259,8 +54164,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_IS_ SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -51389,12 +54292,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FETCH_OBJ_FUN } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CV == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -51455,7 +54352,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -51574,7 +54471,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -51613,7 +54510,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -51730,7 +54627,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = EX_VAR(opline->op1.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CV == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -51769,7 +54822,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -51888,7 +54941,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52203,6 +55256,161 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SP ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CV == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CV == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = EX_VAR(opline->op2.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); +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); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52499,7 +55707,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -52538,7 +55746,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_ASSIGN_OBJ_RE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -53437,6 +56645,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_FUNC_CCONV ZEND_NULL_HANDLER( SAVE_OPLINE(); zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type); + ZEND_VM_NEXT_OPCODE(); /* Never reached */ } @@ -53608,7 +56817,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_STATIC_PRO ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_STATIC_PROP_SPEC_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -53636,26 +56845,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_STATIC_PR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_EX int type); static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_STATIC_PROP_R_SPEC_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_STATIC_PROP_W_SPEC_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_STATIC_PROP_RW_SPEC_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_STATIC_PROP_FUNC_ARG_SPEC_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { @@ -53665,13 +56874,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_STATIC_PROP_ } } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_STATIC_PROP_UNSET_SPEC_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_STATIC_PROP_IS_SPEC_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_static_prop_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); @@ -53721,7 +56930,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_STATIC_PROP value = RT_CONSTANT((opline+1), (opline+1)->op1); if (ZEND_TYPE_IS_SET(prop_info->type)) { - value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); } else { @@ -53759,7 +56968,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_STATIC_PROP value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); if (ZEND_TYPE_IS_SET(prop_info->type)) { - value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } else { value = zend_assign_to_variable_ex(prop, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); @@ -53777,6 +56986,43 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_STATIC_PROP ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *prop, *value; + zend_property_info *prop_info; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + + prop = zend_fetch_static_property_address(&prop_info, opline->extended_value, BP_VAR_W, 0 OPLINE_CC EXECUTE_DATA_CC); + if (UNEXPECTED(!prop)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (ZEND_TYPE_IS_SET(prop_info->type)) { + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } else { + value = zend_assign_to_variable_ex(prop, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + /* assign_static_prop has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -53797,7 +57043,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_STATIC_PROP value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); if (ZEND_TYPE_IS_SET(prop_info->type)) { - value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, prop, value, &garbage, NULL EXECUTE_DATA_CC); } else { @@ -54362,7 +57608,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FCA ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif @@ -54476,7 +57721,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FCA ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif @@ -54589,7 +57833,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FC ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif zend_observer_fcall_end(call, EG(exception) ? NULL : ret); ZEND_VM_FCALL_INTERRUPT_CHECK(call); @@ -54721,7 +57964,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FCA ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif @@ -54852,7 +58094,6 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FCA ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif @@ -54980,7 +58221,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DO_FC ? Z_ISREF_P(ret) : !Z_ISREF_P(ret)); zend_verify_internal_func_info(call->func, ret); } - ZEND_ASSERT(opline->result_type != IS_TMP_VAR || !Z_ISREF_P(ret)); #endif zend_observer_fcall_end(call, EG(exception) ? NULL : ret); ZEND_VM_FCALL_INTERRUPT_CHECK(call); @@ -55786,10 +59026,6 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV zend zval *variable_ptr = EX_VAR(opline->op2.var); zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); } else { - if (UNEXPECTED(Z_ISREF_P(value))) { - value = Z_REFVAL_P(value); - value_type = Z_TYPE_INFO_P(value); - } zval *res = EX_VAR(opline->op2.var); zend_refcounted *gc = Z_COUNTED_P(value); @@ -55931,7 +59167,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_TICKS_SPEC_TAILCAL { USE_OPLINE - if (++EG(ticks_count) >= opline->extended_value) { + if ((uint32_t)++EG(ticks_count) >= opline->extended_value) { EG(ticks_count) = 0; if (zend_ticks_function) { SAVE_OPLINE(); @@ -55969,7 +59205,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_HANDLE_EXCEPTION_S } uint32_t throw_op_num = throw_op - EX(func)->op_array.opcodes; - uint32_t current_try_catch_offset = -1; + int i, current_try_catch_offset = -1; if ((throw_op->opcode == ZEND_FREE || throw_op->opcode == ZEND_FE_FREE) && throw_op->extended_value & ZEND_FREE_ON_RETURN) { @@ -55983,7 +59219,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_HANDLE_EXCEPTION_S } /* Find the innermost try/catch/finally the exception was thrown in */ - for (uint32_t i = 0; i < EX(func)->op_array.last_try_catch; i++) { + for (i = 0; i < EX(func)->op_array.last_try_catch; i++) { zend_try_catch_element *try_catch = &EX(func)->op_array.try_catch_array[i]; if (try_catch->try_op > throw_op_num) { /* further blocks will not be relevant... */ @@ -56823,27 +60059,27 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RECV_I ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_DYNAMIC_CALL_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; zend_execute_data *call; SAVE_OPLINE(); - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); try_function_name: - if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { call = zend_init_dynamic_call_string(Z_STR_P(function_name), opline->extended_value); - } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(function_name) == IS_OBJECT)) { call = zend_init_dynamic_call_object(Z_OBJ_P(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_CV)) && EXPECTED(Z_TYPE_P(function_name) == IS_REFERENCE)) { + } 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 { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { function_name = ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -56854,7 +60090,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_DYNAMIC_CALL_ call = NULL; } - if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (UNEXPECTED(EG(exception))) { if (call) { @@ -57511,8 +60747,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETUR - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); } @@ -57579,9 +60813,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETUR zend_observer_fcall_end(execute_data, return_value); if (return_value == &observer_retval) { zval_ptr_dtor_nogc(&observer_retval); }; - - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); } @@ -57707,8 +60938,10 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_THROW } } while (0); + zend_exception_save(); Z_TRY_ADDREF_P(value); zend_throw_exception_object(value); + zend_exception_restore(); HANDLE_EXCEPTION(); @@ -57722,6 +60955,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CATCH_SPEC_CONST_T SAVE_OPLINE(); /* Check whether an exception has been thrown, if not, jump over code */ + zend_exception_restore(); if (EG(exception) == NULL) { ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); } @@ -58699,38 +61933,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_TYPE_ } } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_TYPE_ASSERT_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - SAVE_OPLINE(); - - zval *value = get_zval_ptr_undef(opline->op2_type, opline->op2, BP_VAR_R); - - uint8_t actual_type = Z_TYPE_P(value); - uint8_t expected_type = opline->extended_value & 0xff; - /* Simple types can be checked directly. */ - if (UNEXPECTED(actual_type != expected_type)) { - zend_function *fbc; - { - zval *fname = (zval*)RT_CONSTANT(opline, opline->op1); - ZEND_ASSERT(Z_EXTRA_P(fname) != 0); - fbc = Z_FUNC(EG(function_table)->arData[Z_EXTRA_P(fname)].val); - ZEND_ASSERT(fbc->type != ZEND_USER_FUNCTION); - } - uint16_t argno = opline->extended_value >> 16; - zend_arg_info *arginfo = &fbc->common.arg_info[argno - 1]; - - if (!zend_check_type(&arginfo->type, value, /* is_return_type */ false, /* is_internal */ true)) { - const char *param_name = get_function_arg_name(fbc, argno); - zend_string *expected = zend_type_to_string(arginfo->type); - zend_type_error("%s(): Argument #%d%s%s%s must be of type %s, %s given", ZSTR_VAL(fbc->common.function_name), argno, param_name ? " ($" : "", param_name ? param_name : "", param_name ? ")" : "", ZSTR_VAL(expected), zend_zval_value_name(value)); - zend_string_release(expected); - } - } - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DEFINED_SPEC_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -59382,17 +62584,13 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } dim = RT_CONSTANT(opline, opline->op2); if (IS_CONST != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CONST == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -59423,8 +62621,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC); @@ -59448,12 +62644,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH if (IS_CONST == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CONST & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -59466,15 +62656,11 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CONST & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -59642,8 +62828,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -59772,12 +62956,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CONST == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -61997,14 +65175,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); div_function(EX_VAR(opline->result.var), op1, op2); @@ -62012,14 +65190,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_CONST_TMP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); pow_function(EX_VAR(opline->result.var), op1, op2); @@ -62027,23 +65205,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_CONST_TMP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); @@ -62051,13 +65229,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CONST_ if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV && @@ -62071,7 +65249,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CONST_ memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -62083,7 +65261,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CONST_ if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } @@ -62094,7 +65272,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CONST_ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { op1 = ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { op2 = ZVAL_UNDEFINED_OP2(); } concat_function(EX_VAR(opline->result.var), op1, op2); @@ -62105,14 +65283,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CONST_ } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); compare_function(EX_VAR(opline->result.var), op1, op2); @@ -62120,24 +65298,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_CON ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *dim, *value; SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_CONST != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_TMP_VAR, BP_VAR_R EXECUTE_DATA_CC); + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CONST == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -62146,13 +65320,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_C } } else { fetch_dim_r_slow: - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } } else { - zend_fetch_dimension_address_read_R(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -62160,23 +65334,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -62188,20 +65360,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CONST & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -62209,15 +65375,11 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CONST & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -62226,7 +65388,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_wrong_property_read(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); ZVAL_NULL(EX_VAR(opline->result.var)); goto fetch_obj_r_finish; } while (0); @@ -62238,7 +65400,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -62298,7 +65460,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -62331,9 +65493,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -62357,7 +65519,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH } #endif - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -62376,7 +65538,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -62384,8 +65546,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -62396,7 +65556,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH break; } } - if (IS_TMP_VAR == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(EX_VAR(opline->result.var)); @@ -62410,7 +65570,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -62437,7 +65597,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -62470,9 +65630,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -62481,7 +65641,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -62500,7 +65660,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -62513,29 +65673,23 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CONST == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_LIST_R_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; @@ -62543,16 +65697,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C op1 = RT_CONSTANT(opline, opline->op1); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if ((IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); @@ -62560,13 +65714,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else if (IS_CONST != IS_CONST && IS_CONST != IS_CV && @@ -62577,7 +65731,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -62589,7 +65743,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } @@ -62607,12 +65761,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C } op1_str = zval_get_string_func(op1); } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { op2_str = Z_STR_P(op2); } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { op2_str = zend_string_copy(Z_STR_P(op2)); } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } op2_str = zval_get_string_func(op2); @@ -62620,7 +65774,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C do { if (IS_CONST != IS_CONST) { if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { GC_ADDREF(op2_str); } @@ -62630,7 +65784,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C break; } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CONST == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { @@ -62651,7 +65805,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C if (IS_CONST != IS_CONST) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_string_release_ex(op2_str, 0); } } while (0); @@ -62661,7 +65815,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -62676,19 +65830,19 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ object = RT_CONSTANT(opline, opline->op1); - if (IS_TMP_VAR != IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST && + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { @@ -62730,14 +65884,14 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { object = ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } HANDLE_EXCEPTION(); } } - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -62750,18 +65904,18 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ called_scope = obj->ce; - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { zend_object *orig_obj = obj; - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); @@ -62772,7 +65926,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ } HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(obj == orig_obj)) { CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); @@ -62788,7 +65942,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -62819,7 +65973,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -62839,7 +65993,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { CACHE_PTR(opline->result.num, ce); } } @@ -62854,24 +66008,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD } if (IS_CONST == IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { /* nothing to do */ } else if (IS_CONST != IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == ce)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_TMP_VAR != IS_UNUSED) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if (IS_TMP_VAR & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -62887,7 +66041,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name)); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { @@ -62896,7 +66050,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) { CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); @@ -62904,7 +66058,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } } else { @@ -62952,7 +66106,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USER_CALL_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -62964,7 +66118,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USER_CALL_SPE uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_DYNAMIC; SAVE_OPLINE(); - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (zend_is_callable_ex(function_name, NULL, 0, NULL, &fcc, &error)) { ZEND_ASSERT(!error); @@ -62972,7 +66126,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USER_CALL_SPE * invoke a user error handler and throw an exception. * For the CONST and CV case we reuse the same exception block below * to make sure we don't increase VM size too much. */ - if (!(IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { + if (!((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } @@ -62997,7 +66151,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USER_CALL_SPE } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if ((IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) && UNEXPECTED(EG(exception))) { if (call_info & ZEND_CALL_CLOSURE) { zend_object_release(ZEND_CLOSURE_OBJECT(func)); } else if (call_info & ZEND_CALL_RELEASE_THIS) { @@ -63024,7 +66178,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_USER_CALL_SPE ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *expr_ptr, new_expr; @@ -63065,15 +66219,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ } } - if (IS_TMP_VAR != IS_UNUSED) { - zval *offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_string *str; zend_ulong hval; add_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index; } @@ -63084,7 +66238,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ hval = Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto add_again; } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { @@ -63117,7 +66271,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -63135,7 +66289,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -63150,14 +66304,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_CO if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { zend_hash_real_init_mixed(Z_ARRVAL_P(array)); } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { ZVAL_ARR(array, zend_new_array(0)); ZEND_VM_NEXT_OPCODE(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -63167,7 +66321,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { HashTable *ht; @@ -63179,17 +66333,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ isset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index_prop; } } - value = zend_hash_find_ex(ht, str, IS_TMP_VAR == IS_CONST); + value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { hval = Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { offset = Z_REFVAL_P(offset); goto isset_again; } else { @@ -63221,7 +66375,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ } } - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } if (!(opline->extended_value & ZEND_ISEMPTY)) { @@ -63237,7 +66391,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -63247,7 +66401,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -63263,7 +66417,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -63275,9 +66429,9 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET result = (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -63288,7 +66442,7 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -63299,14 +66453,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_S SAVE_OPLINE(); key = RT_CONSTANT(opline, opline->op1); - subject = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { array_key_exists_array: ht = Z_ARRVAL_P(subject); result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { subject = Z_REFVAL_P(subject); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { goto array_key_exists_array; @@ -63322,7 +66476,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_S ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CONST_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CONST_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -63409,9 +66563,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CONST_T } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -63478,7 +66632,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_IS_SPEC_CONS ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_CONST_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 @@ -63494,12 +66648,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_UNUSED == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CONST & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -63821,17 +66969,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NEW_SPEC_CONST_UNU zend_function *constructor; zend_class_entry *ce; zend_execute_data *call; + uint32_t cache_slot; + bool has_generic_args = false; SAVE_OPLINE(); if (IS_CONST == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); + cache_slot = opline->op2.num & 0x7FFFFFFF; + has_generic_args = (opline->op2.num & 0x80000000) != 0; + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - CACHE_PTR(opline->op2.num, ce); + CACHE_PTR(cache_slot, ce); } } else if (IS_CONST == IS_UNUSED) { ce = zend_fetch_class(NULL, opline->op1.num); @@ -63849,6 +67001,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NEW_SPEC_CONST_UNU HANDLE_EXCEPTION(); } + /* Bind generic type arguments to the newly created object */ + if (has_generic_args) { + /* Generic args literal is stored at op1.constant + 2 + * (after class name + lowercase class name) */ + zval *generic_args_zv = RT_CONSTANT(opline, opline->op1) + 2; + zend_generic_args *compiled_args = (zend_generic_args *) Z_PTR_P(generic_args_zv); + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(compiled_args); + /* Verify type arguments satisfy constraints (e.g., T: Countable) */ + if (ce->generic_params_info) { + zend_verify_generic_args(ce->generic_params_info, Z_OBJ_P(result)->generic_args); + } + } else if (ce->bound_generic_args) { + /* Inherit bound generic args from class (e.g., IntList extends Collection) */ + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(ce->bound_generic_args); + } + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next @@ -64056,7 +67224,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_VAR_SPEC_CON ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -64101,7 +67269,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_VAR_ ZEND_VM_SMART_BRANCH(result, true); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CONST_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -64621,17 +67789,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_C SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } dim = EX_VAR(opline->op2.var); if (IS_CONST != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CONST == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -64662,8 +67826,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_ SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC); @@ -64687,12 +67849,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_CV == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CONST & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CONST_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -64705,15 +67861,11 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - if (IS_CONST & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CONST & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -64881,8 +68033,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH SAVE_OPLINE(); container = RT_CONSTANT(opline, opline->op1); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CONST == IS_CONST || (IS_CONST != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -65011,12 +68161,6 @@ static ZEND_VM_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CONST == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CONST_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -68015,14 +71159,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_SMA ZEND_VM_SMART_BRANCH_JMPNZ(result, 0); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_LIST_r(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -68051,6 +71195,200 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_LIST_R_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_NOT_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + /* The result and op1 can be the same cv zval */ + const uint32_t orig_val_type = Z_TYPE_INFO_P(val); + ZVAL_TRUE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + } else { + SAVE_OPLINE(); + ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ECHO_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *z; + + SAVE_OPLINE(); + z = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_P(z) == IS_STRING) { + zend_string *str = Z_STR_P(z); + + if (ZSTR_LEN(str) != 0) { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } + } else { + zend_string *str = zval_get_string_func(z); + + if (ZSTR_LEN(str) != 0) { + zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_string_release_ex(str, 0); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPZ_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + uint8_t op1_type; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZEND_VM_NEXT_OPCODE(); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + SAVE_OPLINE(); + op1_type = (IS_TMP_VAR|IS_VAR); + if (i_zend_is_true(val)) { + opline++; + } else { + opline = OP_JMP_ADDR(opline, opline->op2); + } + if (op1_type & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_nogc(val); + } + ZEND_VM_JMP(opline); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPNZ_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + uint8_t op1_type; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + } + ZEND_VM_NEXT_OPCODE(); + } + + SAVE_OPLINE(); + op1_type = (IS_TMP_VAR|IS_VAR); + if (i_zend_is_true(val)) { + opline = OP_JMP_ADDR(opline, opline->op2); + } else { + opline++; + } + if (op1_type & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_nogc(val); + } + ZEND_VM_JMP(opline); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPZ_EX_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + bool ret; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_NEXT_OPCODE(); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + SAVE_OPLINE(); + ret = i_zend_is_true(val); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (ret) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline++; + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline = OP_JMP_ADDR(opline, opline->op2); + } + ZEND_VM_JMP(opline); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPNZ_EX_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val; + bool ret; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + ZEND_VM_NEXT_OPCODE(); + } + } + + SAVE_OPLINE(); + ret = i_zend_is_true(val); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (ret) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + opline = OP_JMP_ADDR(opline, opline->op2); + } else { + ZVAL_FALSE(EX_VAR(opline->result.var)); + opline++; + } + ZEND_VM_JMP(opline); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FREE_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -68085,943 +71423,979 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_FRE ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_THROW_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container, *dim, *value; + zval *value; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - dim = RT_CONSTANT(opline, opline->op2); - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { -fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC); - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto fetch_dim_r_array; - } else { - goto fetch_dim_r_slow; + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + do { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) { + break; + } } - } else { -fetch_dim_r_slow: - if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } } - zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); + zend_throw_error(NULL, "Can only throw objects"); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } - } else { - zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC); - } - + } while (0); + zend_exception_save(); + Z_TRY_ADDREF_P(value); + zend_throw_exception_object(value); + zend_exception_restore(); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + HANDLE_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - - SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC); - + zval *val; - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (Z_TYPE_INFO_P(val) == IS_TRUE) { + ZVAL_TRUE(EX_VAR(opline->result.var)); + } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { + /* The result and op1 can be the same cv zval */ + const uint32_t orig_val_type = Z_TYPE_INFO_P(val); + ZVAL_FALSE(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + } else { + SAVE_OPLINE(); + ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CLONE_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - void **cache_slot = NULL; + zval *obj; + zend_object *zobj; + zend_class_entry *ce, *scope; + zend_function *clone; + zend_object_clone_obj_t clone_call; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } + obj = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST || - ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - do { - if (((IS_TMP_VAR|IS_VAR) & IS_CV) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + /* ZEND_CLONE also exists as the clone() function and both implementations must be kept in sync. + * The OPcode intentionally does not support a clone-with property list to keep it simple. */ + + do { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) { + obj = Z_REFVAL_P(obj); + if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) { break; } } - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } } - zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2)); - ZVAL_NULL(EX_VAR(opline->result.var)); - goto fetch_obj_r_finish; - } while (0); - } - - /* here we are sure we are dealing with an object */ - do { - zend_object *zobj = Z_OBJ_P(container); - zend_string *name, *tmp_name; - zval *retval; - - if (IS_CONST == IS_CONST) { - cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); - - if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { - uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zend_type_error("clone(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(obj)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } while (0); - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { -fetch_obj_r_simple: - retval = OBJ_PROP(zobj, prop_offset); - if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) { - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { -fetch_obj_r_fast_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - ZEND_VM_NEXT_OPCODE(); - } - } - } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { - zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); - if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { - prop_offset = prop_info->offset; - goto fetch_obj_r_simple; - } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) { - zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET]; - ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION); - ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array)); + zobj = Z_OBJ_P(obj); + ce = zobj->ce; + clone = ce->clone; + clone_call = zobj->handlers->clone_obj; + if (UNEXPECTED(clone_call == NULL)) { + zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if ((IS_TMP_VAR|IS_VAR) & IS_CV) { - GC_ADDREF(zobj); - } - if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) { - call_info |= ZEND_CALL_RELEASE_THIS; - } - zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj); - call->prev_execute_data = execute_data; - call->call = NULL; - call->return_value = EX_VAR(opline->result.var); - call->run_time_cache = RUN_TIME_CACHE(&hook->op_array); + if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) { + scope = EX(func)->op_array.scope; + ZEND_ASSERT(!(clone->common.fn_flags & ZEND_ACC_PUBLIC)); + if (!zend_check_method_accessible(clone, scope)) { + zend_bad_method_call(clone, clone->common.function_name, scope); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } - execute_data = call; - EG(current_execute_data) = execute_data; - zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); + ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj)); -#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; -#else - EX(opline) = hook->op_array.opcodes; -#endif - LOAD_OPLINE_EX(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_op_array *new_op_array; + zval *inc_filename; + SAVE_OPLINE(); + inc_filename = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } + UNDEF_RESULT(); + 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 (UNEXPECTED(new_op_array == NULL)) { + if (RETURN_VALUE_USED(opline)) { + ZVAL_FALSE(EX_VAR(opline->result.var)); + } + } else if (new_op_array->last == 1 + && new_op_array->opcodes[0].opcode == ZEND_RETURN + && new_op_array->opcodes[0].op1_type == IS_CONST + && EXPECTED(zend_execute_ex == execute_ex)) { + if (RETURN_VALUE_USED(opline)) { + const zend_op *op = new_op_array->opcodes; + ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); + } + zend_destroy_static_vars(new_op_array); + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + } else { + zval *return_value = NULL; + zend_execute_data *call; + if (RETURN_VALUE_USED(opline)) { + return_value = EX_VAR(opline->result.var); + } - ZEND_VM_ENTER_EX(); - } - /* Fall through to read_property for hooks. */ - } else if (EXPECTED(zobj->properties != NULL)) { - ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { - uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + new_op_array->scope = EX(func)->op_array.scope; - if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { - Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + call = zend_vm_stack_push_call_frame( + (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, + (zend_function*)new_op_array, 0, + Z_PTR(EX(This))); - if (EXPECTED(p->key == name) || - (EXPECTED(p->h == ZSTR_H(name)) && - EXPECTED(p->key != NULL) && - EXPECTED(zend_string_equal_content(p->key, name)))) { - retval = &p->val; - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { - goto fetch_obj_r_fast_copy; - } - } - } - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); - } - retval = zend_hash_find_known_hash(zobj->properties, name); - if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { - goto fetch_obj_r_fast_copy; - } - } - } - } - name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + if (EX_CALL_INFO() & ZEND_CALL_HAS_SYMBOL_TABLE) { + call->symbol_table = EX(symbol_table); } else { - name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); - if (UNEXPECTED(!name)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - break; - } + call->symbol_table = zend_rebuild_symbol_table(); } -#if ZEND_DEBUG - /* For non-standard object handlers, verify a declared property type in debug builds. - * Fetch prop_info before calling read_property(), as it may deallocate the object. */ - zend_property_info *prop_info = NULL; - if (zobj->handlers->read_property != zend_std_read_property) { - prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true); - } -#endif - retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var)); -#if ZEND_DEBUG - if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO - && ZEND_TYPE_IS_SET(prop_info->type)) { - ZVAL_OPT_DEREF(retval); - zend_verify_property_type(prop_info, retval, /* strict */ true); - } -#endif + call->prev_execute_data = execute_data; + i_init_code_execute_data(call, new_op_array, return_value); - if (IS_CONST != IS_CONST) { - zend_tmp_string_release(tmp_name); - } - if (retval != EX_VAR(opline->result.var)) { -fetch_obj_r_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - } else if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_unwrap_reference(retval); + if (EXPECTED(zend_execute_ex == execute_ex)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_ENTER(); + } else { + ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); + zend_execute_ex(call); + zend_vm_stack_free_call_frame(call); } - } while (0); - -fetch_obj_r_finish: - + zend_destroy_static_vars(new_op_array); + destroy_op_array(new_op_array); + efree_size(new_op_array, sizeof(zend_op_array)); + if (UNEXPECTED(EG(exception) != NULL)) { + zend_rethrow_exception(execute_data); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_FROM_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - void **cache_slot = NULL; + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + zval *val; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST || - ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - do { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - break; - } - } - if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { - ZVAL_UNDEFINED_OP2(); - } - ZVAL_NULL(EX_VAR(opline->result.var)); - goto fetch_obj_is_finish; - } while (0); + if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) { + zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator"); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); } - /* here we are sure we are dealing with an object */ - do { - zend_object *zobj = Z_OBJ_P(container); - zend_string *name, *tmp_name; - zval *retval; - - if (IS_CONST == IS_CONST) { - cache_slot = CACHE_ADDR(opline->extended_value); - - if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { - uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { -fetch_obj_is_simple: - retval = OBJ_PROP(zobj, prop_offset); - if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) { - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { -fetch_obj_is_fast_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - ZEND_VM_NEXT_OPCODE(); - } - } - } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { - if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { - zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); - prop_offset = prop_info->offset; - goto fetch_obj_is_simple; - } - /* Fall through to read_property for hooks. */ - } else if (EXPECTED(zobj->properties != NULL)) { - ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { - uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); +yield_from_try_again: + if (Z_TYPE_P(val) == IS_ARRAY) { + ZVAL_COPY_VALUE(&generator->values, val); + if (Z_OPT_REFCOUNTED_P(val)) { + Z_ADDREF_P(val); + } + Z_FE_POS(generator->values) = 0; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) { + zend_class_entry *ce = Z_OBJCE_P(val); + if (ce == zend_ce_generator) { + zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val); - if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { - Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + Z_ADDREF_P(val); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (EXPECTED(p->key == name) || - (EXPECTED(p->h == ZSTR_H(name)) && - EXPECTED(p->key != NULL) && - EXPECTED(zend_string_equal_content(p->key, name)))) { - retval = &p->val; - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { - goto fetch_obj_is_fast_copy; - } - } - } - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); - } - retval = zend_hash_find_known_hash(zobj->properties, name); - if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { - goto fetch_obj_is_fast_copy; - } - } + if (UNEXPECTED(new_gen->execute_data == NULL)) { + zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue"); + zval_ptr_dtor(val); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } else if (Z_ISUNDEF(new_gen->retval)) { + if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) { + zend_throw_error(NULL, "Impossible to yield from the Generator being currently run"); + zval_ptr_dtor(val); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } else { + zend_generator_yield_from(generator, new_gen); + } + } else { + if (RETURN_VALUE_USED(opline)) { + ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); } + ZEND_VM_NEXT_OPCODE(); } - name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); } else { - name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); - if (UNEXPECTED(!name)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - break; + zend_object_iterator *iter = ce->get_iterator(ce, val, 0); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) { + if (!EG(exception)) { + zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); + } + UNDEF_RESULT(); + HANDLE_EXCEPTION(); } - } - retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); + iter->index = 0; + if (iter->funcs->rewind) { + iter->funcs->rewind(iter); + if (UNEXPECTED(EG(exception) != NULL)) { + OBJ_RELEASE(&iter->std); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } + } - if (IS_CONST != IS_CONST) { - zend_tmp_string_release(tmp_name); + ZVAL_OBJ(&generator->values, &iter->std); } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) { + val = Z_REFVAL_P(val); + goto yield_from_try_again; + } else { + zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables"); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + UNDEF_RESULT(); + HANDLE_EXCEPTION(); + } - if (retval != EX_VAR(opline->result.var)) { -fetch_obj_is_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - } else if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_unwrap_reference(retval); - } - } while (0); + /* This is the default return value + * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ + if (RETURN_VALUE_USED(opline)) { + ZVAL_NULL(EX_VAR(opline->result.var)); + } -fetch_obj_is_finish: + /* This generator has no send target (though the generator we delegate to might have one) */ + generator->send_target = NULL; + /* The GOTO VM uses a local opline variable. We need to set the opline + * variable in execute_data so we don't resume at an old position. */ + SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_RETURN(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_STRLEN_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value, *arg; + zval *value; - if (IS_CONST == IS_CONST) { - SAVE_OPLINE(); - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - uint32_t arg_num; - arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!arg)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { + ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(value); } + ZEND_VM_NEXT_OPCODE(); } else { - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - } + bool strict; - value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - ZVAL_COPY_VALUE(arg, value); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) { + value = Z_REFVAL_P(value); + if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { + ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } + } + + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + value = ZVAL_UNDEFINED_OP1(); } + strict = EX_USES_STRICT_TYPES(); + do { + if (EXPECTED(!strict)) { + zend_string *str; + zval tmp; + + if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) { + zend_error(E_DEPRECATED, + "strlen(): Passing null to parameter #1 ($string) of type string is deprecated"); + ZVAL_LONG(EX_VAR(opline->result.var), 0); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + break; + } + + ZVAL_COPY(&tmp, value); + if (zend_parse_arg_str_weak(&tmp, &str, 1)) { + ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); + zval_ptr_dtor(&tmp); + break; + } + zval_ptr_dtor(&tmp); + } + if (!EG(exception)) { + zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value)); + } + ZVAL_UNDEF(EX_VAR(opline->result.var)); + } while (0); } - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_TYPE_CHECK_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container, *dim, *value; - zend_long offset; - HashTable *ht; + zval *value; + int result = 0; - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - dim = RT_CONSTANT(opline, opline->op2); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { -fetch_dim_r_index_array: - if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { - offset = Z_LVAL_P(dim); - } else { - SAVE_OPLINE(); - zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - ZEND_VM_NEXT_OPCODE(); + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { +type_check_resource: + if (opline->extended_value != MAY_BE_RESOURCE + || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { + result = 1; } - } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto fetch_dim_r_index_array; - } else { - goto fetch_dim_r_index_slow; + } else if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { + goto type_check_resource; } - } else { -fetch_dim_r_index_slow: + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + result = ((1 << IS_NULL) & opline->extended_value) != 0; SAVE_OPLINE(); - if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception))) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_SMART_BRANCH(result, 1); + } else { + ZEND_VM_SMART_BRANCH(result, 0); } - -fetch_dim_r_index_undef: - ZVAL_NULL(EX_VAR(opline->result.var)); - SAVE_OPLINE(); - zend_undefined_offset(offset); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + uint32_t fetch_type; + zend_class_entry *called_scope, *scope; USE_OPLINE - zval *container, *dim, *value; - zend_long offset; - HashTable *ht; - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - dim = EX_VAR(opline->op2.var); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { -fetch_dim_r_index_array: - if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { - offset = Z_LVAL_P(dim); - } else { - SAVE_OPLINE(); - zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ht = Z_ARRVAL_P(container); - ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - ZEND_VM_NEXT_OPCODE(); - } - } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto fetch_dim_r_index_array; - } else { - goto fetch_dim_r_index_slow; - } - } else { -fetch_dim_r_index_slow: + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { SAVE_OPLINE(); - if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + zval *op = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) { + ZVAL_DEREF(op); + if (Z_TYPE_P(op) != IS_OBJECT) { + zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } } - zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); + + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -fetch_dim_r_index_undef: - ZVAL_NULL(EX_VAR(opline->result.var)); - SAVE_OPLINE(); - zend_undefined_offset(offset); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container, *dim, *value; - - SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); + fetch_type = opline->op1.num; + scope = EX(func)->op_array.scope; + if (UNEXPECTED(scope == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, "Cannot use \"%s\" in the global scope", + fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : + fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { -fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_TMP_VAR, BP_VAR_R EXECUTE_DATA_CC); - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto fetch_dim_r_array; - } else { - goto fetch_dim_r_slow; + + switch (fetch_type) { + case ZEND_FETCH_CLASS_SELF: + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); + break; + case ZEND_FETCH_CLASS_PARENT: + if (UNEXPECTED(scope->parent == NULL)) { + SAVE_OPLINE(); + zend_throw_error(NULL, + "Cannot use \"parent\" when current class scope has no parent"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - } else { -fetch_dim_r_slow: - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; + ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); + break; + case ZEND_FETCH_CLASS_STATIC: + if (Z_TYPE(EX(This)) == IS_OBJECT) { + called_scope = Z_OBJCE(EX(This)); + } else { + called_scope = Z_CE(EX(This)); } - zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); - } - } else { - zend_fetch_dimension_address_read_R(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name); + break; + EMPTY_SWITCH_DEFAULT_CASE() } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; + zval *op1, *op2; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + div_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - void **cache_slot = NULL; + zval *op1, *op2; SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - - if ((IS_TMP_VAR|IS_VAR) == IS_CONST || - ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - do { - if (((IS_TMP_VAR|IS_VAR) & IS_CV) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - break; - } - } - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - zend_wrong_property_read(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); - ZVAL_NULL(EX_VAR(opline->result.var)); - goto fetch_obj_r_finish; - } while (0); - } - - /* here we are sure we are dealing with an object */ - do { - zend_object *zobj = Z_OBJ_P(container); - zend_string *name, *tmp_name; - zval *retval; - - if (IS_TMP_VAR == IS_CONST) { - cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); - - if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { - uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { -fetch_obj_r_simple: - retval = OBJ_PROP(zobj, prop_offset); - if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) { - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { -fetch_obj_r_fast_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - ZEND_VM_NEXT_OPCODE(); - } - } - } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { - zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); - if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { - prop_offset = prop_info->offset; - goto fetch_obj_r_simple; - } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) { - zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET]; - ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION); - ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array)); - - uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if ((IS_TMP_VAR|IS_VAR) & IS_CV) { - GC_ADDREF(zobj); - } - if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) { - call_info |= ZEND_CALL_RELEASE_THIS; - } - zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj); - call->prev_execute_data = execute_data; - call->call = NULL; - call->return_value = EX_VAR(opline->result.var); - call->run_time_cache = RUN_TIME_CACHE(&hook->op_array); - - execute_data = call; - EG(current_execute_data) = execute_data; - zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + pow_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); -#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) - opline = hook->op_array.opcodes; -#else - EX(opline) = hook->op_array.opcodes; -#endif - LOAD_OPLINE_EX(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); - ZEND_VM_ENTER_EX(); - } - /* Fall through to read_property for hooks. */ - } else if (EXPECTED(zobj->properties != NULL)) { - ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); - if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { - uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { - Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); - if (EXPECTED(p->key == name) || - (EXPECTED(p->h == ZSTR_H(name)) && - EXPECTED(p->key != NULL) && - EXPECTED(zend_string_equal_content(p->key, name)))) { - retval = &p->val; - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { - goto fetch_obj_r_fast_copy; - } - } - } - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); - } - retval = zend_hash_find_known_hash(zobj->properties, name); - if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_r_copy; - } else { - goto fetch_obj_r_fast_copy; - } - } - } + if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { + zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); + } + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); - if (UNEXPECTED(!name)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - break; + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } } + ZEND_VM_NEXT_OPCODE(); + } else { + SAVE_OPLINE(); -#if ZEND_DEBUG - /* For non-standard object handlers, verify a declared property type in debug builds. - * Fetch prop_info before calling read_property(), as it may deallocate the object. */ - zend_property_info *prop_info = NULL; - if (zobj->handlers->read_property != zend_std_read_property) { - prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true); - } -#endif - retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var)); -#if ZEND_DEBUG - if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO - && ZEND_TYPE_IS_SET(prop_info->type)) { - ZVAL_OPT_DEREF(retval); - zend_verify_property_type(prop_info, retval, /* strict */ true); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + op1 = ZVAL_UNDEFINED_OP1(); } -#endif - - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + op2 = ZVAL_UNDEFINED_OP2(); } + concat_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (retval != EX_VAR(opline->result.var)) { -fetch_obj_r_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - } else if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_unwrap_reference(retval); - } - } while (0); -fetch_obj_r_finish: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *container; - void **cache_slot = NULL; - - SAVE_OPLINE(); - container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ + zval *op1, *op2; + double d1, d2; - if ((IS_TMP_VAR|IS_VAR) == IS_CONST || - ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - do { - if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - break; - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); } - if (IS_TMP_VAR == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { - ZVAL_UNDEFINED_OP2(); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; } - ZVAL_NULL(EX_VAR(opline->result.var)); - goto fetch_obj_is_finish; - } while (0); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - /* here we are sure we are dealing with an object */ - do { - zend_object *zobj = Z_OBJ_P(container); - zend_string *name, *tmp_name; - zval *retval; - - if (IS_TMP_VAR == IS_CONST) { - cache_slot = CACHE_ADDR(opline->extended_value); - - if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { - uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { -fetch_obj_is_simple: - retval = OBJ_PROP(zobj, prop_offset); - if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) { - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { -fetch_obj_is_fast_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - ZEND_VM_NEXT_OPCODE(); - } - } - } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { - if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { - zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); - prop_offset = prop_info->offset; - goto fetch_obj_is_simple; - } - /* Fall through to read_property for hooks. */ - } else if (EXPECTED(zobj->properties != NULL)) { - ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); - if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { - uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); - - if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { - Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - if (EXPECTED(p->key == name) || - (EXPECTED(p->h == ZSTR_H(name)) && - EXPECTED(p->key != NULL) && - EXPECTED(zend_string_equal_content(p->key, name)))) { - retval = &p->val; - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { - goto fetch_obj_is_fast_copy; - } - } - } - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); - } - retval = zend_hash_find_known_hash(zobj->properties, name); - if (EXPECTED(retval)) { - uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; - CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); - if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { - goto fetch_obj_is_copy; - } else { - goto fetch_obj_is_fast_copy; - } - } - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); - } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); - if (UNEXPECTED(!name)) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - break; + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; } } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; } - - if (retval != EX_VAR(opline->result.var)) { -fetch_obj_is_copy: - ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); - } else if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_unwrap_reference(retval); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; } - } while (0); - -fetch_obj_is_finish: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value, *arg; + zval *op1, *op2; + double d1, d2; - if (IS_UNUSED == IS_CONST) { - SAVE_OPLINE(); - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - uint32_t arg_num; - arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!arg)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; } - } else { - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - } - - value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - ZVAL_COPY_VALUE(arg, value); - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } } } - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *varname; - zend_string *name, *tmp_name; - HashTable *target_symbol_table; + zval *op1, *op2; + double d1, d2; - SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { - name = Z_STR_P(varname); - } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { - name = Z_STR_P(varname); - tmp_name = NULL; - } else { - if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { - varname = ZVAL_UNDEFINED_OP1(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && IS_CONST == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; } - name = zval_try_get_tmp_string(varname, &tmp_name); - if (UNEXPECTED(!name)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } } } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); - zend_hash_del_ind(target_symbol_table, name); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; - if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { - zend_tmp_string_release(tmp_name); - } + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + compare_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - zval *result = EX_VAR(opline->result.var); - ZVAL_COPY(result, value); - ZEND_VM_NEXT_OPCODE(); + zval *op1, *op2; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + boolean_xor_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *dim, *value; SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - dim = EX_VAR(opline->op2.var); + dim = RT_CONSTANT(opline, opline->op2); if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC); + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -69030,13 +72404,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_T } } else { fetch_dim_r_slow: - if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } } else { - zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC); } @@ -69044,23 +72418,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_T ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -69068,15 +72440,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_T SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if ((IS_TMP_VAR|IS_VAR) == IS_CONST || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if (((IS_TMP_VAR|IS_VAR) & IS_CV) && Z_ISREF_P(container)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -69085,7 +72453,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_T if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + zend_wrong_property_read(container, RT_CONSTANT(opline, opline->op2)); ZVAL_NULL(EX_VAR(opline->result.var)); goto fetch_obj_r_finish; } while (0); @@ -69097,7 +72465,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_T zend_string *name, *tmp_name; zval *retval; - if (IS_CV == IS_CONST) { + if (IS_CONST == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -69157,7 +72525,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_T /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -69190,9 +72558,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_T } } } - name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -69216,7 +72584,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_T } #endif - if (IS_CV != IS_CONST) { + if (IS_CONST != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -69235,7 +72603,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_T ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -69243,8 +72611,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ SAVE_OPLINE(); container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if ((IS_TMP_VAR|IS_VAR) == IS_CONST || ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -69255,7 +72621,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ break; } } - if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + if (IS_CONST == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(EX_VAR(opline->result.var)); @@ -69269,7 +72635,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ zend_string *name, *tmp_name; zval *retval; - if (IS_CV == IS_CONST) { + if (IS_CONST == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -69296,7 +72662,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -69329,9 +72695,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ } } } - name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -69340,7 +72706,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - if (IS_CV != IS_CONST) { + if (IS_CONST != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -69359,1461 +72725,1571 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_NOT_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val; - - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - /* The result and op1 can be the same cv zval */ - const uint32_t orig_val_type = Z_TYPE_INFO_P(val); - ZVAL_TRUE(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - } else { - SAVE_OPLINE(); - ZVAL_BOOL(EX_VAR(opline->result.var), !i_zend_is_true(val)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - ZEND_VM_NEXT_OPCODE(); -} + zval *op1, *op2; + zend_string *op1_str, *op2_str, *str; -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ECHO_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *z; - SAVE_OPLINE(); - z = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - if (Z_TYPE_P(z) == IS_STRING) { - zend_string *str = Z_STR_P(z); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); - if (ZSTR_LEN(str) != 0) { - zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else { + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } } - } else { - zend_string *str = zval_get_string_func(z); + ZEND_VM_NEXT_OPCODE(); + } - if (ZSTR_LEN(str) != 0) { - zend_write(ZSTR_VAL(str), ZSTR_LEN(str)); - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(z) == IS_UNDEF)) { + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + op1_str = Z_STR_P(op1); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + op1_str = zend_string_copy(Z_STR_P(op1)); + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_string_release_ex(str, 0); + op1_str = zval_get_string_func(op1); + } + if (IS_CONST == IS_CONST) { + op2_str = Z_STR_P(op2); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + op2_str = zend_string_copy(Z_STR_P(op2)); + } else { + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + } + op2_str = zval_get_string_func(op2); } + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { + GC_ADDREF(op2_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + zend_string_release_ex(op1_str, 0); + break; + } + } + if (IS_CONST != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { + GC_ADDREF(op1_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + zend_string_release_ex(op2_str, 0); + break; + } + } + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CONST != IS_CONST) { + zend_string_release_ex(op2_str, 0); + } + } while (0); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPZ_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val; - uint8_t op1_type; + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + SAVE_OPLINE(); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZEND_VM_NEXT_OPCODE(); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CONST != IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + if (IS_CONST != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } } - } - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + zend_throw_error(NULL, "Method name must be a string"); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); } - SAVE_OPLINE(); - op1_type = IS_TMP_VAR; - if (i_zend_is_true(val)) { - opline++; + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + obj = Z_OBJ_P(object); } else { - opline = OP_JMP_ADDR(opline, opline->op2); - } - if (op1_type & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_nogc(val); - } - ZEND_VM_JMP(opline); -} + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + } else { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + zend_reference *ref = Z_REF_P(object); -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPNZ_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *val; - uint8_t op1_type; + object = &ref->val; + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else { + Z_ADDREF_P(object); + } + } + break; + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CONST != IS_CONST) { - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { + } + HANDLE_EXCEPTION(); + } + } + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + zend_invalid_method_call(object, function_name); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); HANDLE_EXCEPTION(); } - } - ZEND_VM_NEXT_OPCODE(); + } while (0); } - SAVE_OPLINE(); - op1_type = IS_TMP_VAR; - if (i_zend_is_true(val)) { - opline = OP_JMP_ADDR(opline, opline->op2); + called_scope = obj->ce; + + if (IS_CONST == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { - opline++; - } - if (op1_type & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_nogc(val); + zend_object *orig_obj = obj; + + if (IS_CONST == IS_CONST) { + function_name = RT_CONSTANT(opline, opline->op2); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); + } + + + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); + } + HANDLE_EXCEPTION(); + } + if (IS_CONST == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + GC_ADDREF(obj); /* For $this pointer */ + if (GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); + } + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } } - ZEND_VM_JMP(opline); -} -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPZ_EX_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *val; - bool ret; + if (IS_CONST != IS_CONST) { - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - ZEND_VM_NEXT_OPCODE(); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { + zend_objects_store_del(obj); if (UNEXPECTED(EG(exception))) { HANDLE_EXCEPTION(); } } - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; } - SAVE_OPLINE(); - ret = i_zend_is_true(val); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (ret) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - opline++; - } else { - ZVAL_FALSE(EX_VAR(opline->result.var)); - opline = OP_JMP_ADDR(opline, opline->op2); - } - ZEND_VM_JMP(opline); + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMPNZ_EX_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val; - bool ret; - - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + zval *value, *arg; - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(val) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - ZEND_VM_NEXT_OPCODE(); + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); } - SAVE_OPLINE(); - ret = i_zend_is_true(val); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (ret) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - opline = OP_JMP_ADDR(opline, opline->op2); - } else { - ZVAL_FALSE(EX_VAR(opline->result.var)); - opline++; + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } } - ZEND_VM_JMP(opline); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETURN_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval_ptr; - zval *return_value; - - - retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - return_value = EX(return_value); - + zval *op1, *op2; + double d1, d2; - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { - SAVE_OPLINE(); - retval_ptr = ZVAL_UNDEFINED_OP1(); - if (return_value) { - ZVAL_NULL(return_value); - } - } else if (!return_value) { - if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { - if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { - SAVE_OPLINE(); - rc_dtor_func(Z_COUNTED_P(retval_ptr)); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +case_true: + ZEND_VM_SMART_BRANCH_TRUE(); + } else { +case_false: + ZEND_VM_SMART_BRANCH_FALSE(); } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto case_double; } - } else { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { - Z_ADDREF_P(return_value); - } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +case_double: + if (d1 == d2) { + goto case_true; + } else { + goto case_false; } - } else if (IS_TMP_VAR == IS_CV) { - do { - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { - if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (GC_MAY_LEAK(ref)) { - SAVE_OPLINE(); - gc_possible_root(ref); - } - ZVAL_NULL(retval_ptr); - break; - } else { - Z_ADDREF_P(retval_ptr); - } - } else { - retval_ptr = Z_REFVAL_P(retval_ptr); - if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } - } - } - ZVAL_COPY_VALUE(return_value, retval_ptr); - } while (0); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto case_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - retval_ptr = Z_REFVAL_P(retval_ptr); - ZVAL_COPY_VALUE(return_value, retval_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } + + if (result) { + goto case_true; } else { - ZVAL_COPY_VALUE(return_value, retval_ptr); + goto case_false; } } } - - - - - - - ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); + ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETURN_BY_REF_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval_ptr; - zval *return_value; - + zval *container; + bool result; + zend_ulong hval; + zval *offset; SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = RT_CONSTANT(opline, opline->op2); - return_value = EX(return_value); - - - do { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) || - (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { - /* Not supposed to happen, but we'll allow it */ - zend_error(E_NOTICE, "Only variable references should be returned by reference"); - - retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (!return_value) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } else { - if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { - ZVAL_COPY_VALUE(return_value, retval_ptr); - break; - } + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + HashTable *ht; + zval *value; + zend_string *str; - ZVAL_NEW_REF(return_value, retval_ptr); - if (IS_TMP_VAR == IS_CONST) { - Z_TRY_ADDREF_P(retval_ptr); +isset_dim_obj_array: + ht = Z_ARRVAL_P(container); +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; } } - break; + value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + offset = Z_REFVAL_P(offset); + goto isset_again; + } else { + value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); + if (UNEXPECTED(EG(exception))) { + result = 0; + goto isset_dim_obj_exit; + } } - retval_ptr = zend_get_bad_ptr(); + if (!(opline->extended_value & ZEND_ISEMPTY)) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); - if (IS_TMP_VAR == IS_VAR) { - ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); - if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { - zend_error(E_NOTICE, "Only variable references should be returned by reference"); - if (return_value) { - ZVAL_NEW_REF(return_value, retval_ptr); - } else { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } - break; - } - } + if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { + /* avoid exception check */ - if (return_value) { - if (Z_ISREF_P(retval_ptr)) { - Z_ADDREF_P(retval_ptr); - } else { - ZVAL_MAKE_REF_EX(retval_ptr, 2); + + ZEND_VM_SMART_BRANCH(result, 0); } - ZVAL_REF(return_value, Z_REF_P(retval_ptr)); + } else { + result = (value == NULL || !i_zend_is_true(value)); } + goto isset_dim_obj_exit; + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto isset_dim_obj_array; + } + } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } while (0); - - + if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + offset++; + } + if (!(opline->extended_value & ZEND_ISEMPTY)) { + result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); + } else { + result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); + } +isset_dim_obj_exit: - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GENERATOR_RETURN_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *retval; - - zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + zval *container; + int result; + zval *offset; + zend_string *name, *tmp_name; SAVE_OPLINE(); - retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = RT_CONSTANT(opline, opline->op2); - /* Copy return value into generator->retval */ - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZVAL_COPY_VALUE(&generator->retval, retval); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { - Z_ADDREF(generator->retval); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } + } else { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } - } else if (IS_TMP_VAR == IS_CV) { - ZVAL_COPY_DEREF(&generator->retval, retval); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(retval))) { - zend_refcounted *ref = Z_COUNTED_P(retval); + } - retval = Z_REFVAL_P(retval); - ZVAL_COPY_VALUE(&generator->retval, retval); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(retval)) { - Z_ADDREF_P(retval); - } - } else { - ZVAL_COPY_VALUE(&generator->retval, retval); + if (IS_CONST == IS_CONST) { + name = Z_STR_P(offset); + } else { + name = zval_try_get_tmp_string(offset, &tmp_name); + if (UNEXPECTED(!name)) { + result = 0; + goto isset_object_finish; } } + result = + (opline->extended_value & ZEND_ISEMPTY) ^ + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - EG(current_execute_data) = EX(prev_execute_data); + if (IS_CONST != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - /* Close the generator to free up resources */ - zend_generator_close(generator, 1); +isset_object_finish: - /* Pass execution back to handling code */ - ZEND_VM_RETURN(); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_THROW_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; + + zval *key, *subject; + HashTable *ht; + bool result; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - do { - if (IS_TMP_VAR == IS_CONST || UNEXPECTED(Z_TYPE_P(value) != IS_OBJECT)) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - if (EXPECTED(Z_TYPE_P(value) == IS_OBJECT)) { - break; - } - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } + key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + subject = RT_CONSTANT(opline, opline->op2); + + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { +array_key_exists_array: + ht = Z_ARRVAL_P(subject); + result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); + } else { + if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + subject = Z_REFVAL_P(subject); + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { + goto array_key_exists_array; } - zend_throw_error(NULL, "Can only throw objects"); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); } - } while (0); + zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); + result = 0; + } + - Z_TRY_ADDREF_P(value); - zend_throw_exception_object(value); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *arg, *param; + zval *expr; + bool result; SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - param = ZEND_CALL_VAR(EX(call), opline->result.var); - if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { - zend_param_must_be_ref(EX(call)->func, opline->op2.num); - Z_TRY_ADDREF_P(arg); - ZVAL_NEW_REF(param, arg); +try_instanceof: + if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; + + if (IS_CONST == IS_CONST) { + ce = CACHED_PTR(cache_slot); + if (UNEXPECTED(ce == NULL)) { + ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); + if (EXPECTED(ce)) { + CACHE_PTR(cache_slot, ce); + } + } + } else if (IS_CONST == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op2.var)); + } + result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_CONST == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { + expr = Z_REFVAL_P(expr); + goto try_instanceof; } else { - ZVAL_COPY(param, arg); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + result = 0; } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val; + zval *container, *dim, *value; + zend_long offset; + HashTable *ht; - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (Z_TYPE_INFO_P(val) == IS_TRUE) { - ZVAL_TRUE(EX_VAR(opline->result.var)); - } else if (EXPECTED(Z_TYPE_INFO_P(val) <= IS_TRUE)) { - /* The result and op1 can be the same cv zval */ - const uint32_t orig_val_type = Z_TYPE_INFO_P(val); - ZVAL_FALSE(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(orig_val_type == IS_UNDEF)) { + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + dim = RT_CONSTANT(opline, opline->op2); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +fetch_dim_r_index_array: + if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { + offset = Z_LVAL_P(dim); + } else { SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); + zend_fetch_dimension_address_read_R(container, dim, IS_CONST OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + ht = Z_ARRVAL_P(container); + ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + ZEND_VM_NEXT_OPCODE(); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto fetch_dim_r_index_array; + } else { + goto fetch_dim_r_index_slow; } } else { +fetch_dim_r_index_slow: SAVE_OPLINE(); - ZVAL_BOOL(EX_VAR(opline->result.var), i_zend_is_true(val)); + if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - ZEND_VM_NEXT_OPCODE(); + +fetch_dim_r_index_undef: + ZVAL_NULL(EX_VAR(opline->result.var)); + SAVE_OPLINE(); + zend_undefined_offset(offset); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CLONE_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *obj; - zend_object *zobj; - zend_class_entry *ce, *scope; - zend_function *clone; - zend_object_clone_obj_t clone_call; - - SAVE_OPLINE(); - obj = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - /* ZEND_CLONE also exists as the clone() function and both implementations must be kept in sync. - * The OPcode intentionally does not support a clone-with property list to keep it simple. */ + zval *container, *dim, *value; + zend_long offset; + HashTable *ht; - do { - if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(obj) != IS_OBJECT))) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(obj)) { - obj = Z_REFVAL_P(obj); - if (EXPECTED(Z_TYPE_P(obj) == IS_OBJECT)) { - break; - } - } - ZVAL_UNDEF(EX_VAR(opline->result.var)); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(obj) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - zend_type_error("clone(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(obj)); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + dim = EX_VAR(opline->op2.var); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +fetch_dim_r_index_array: + if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) { + offset = Z_LVAL_P(dim); + } else { + SAVE_OPLINE(); + zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR|IS_CV) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - } while (0); - - zobj = Z_OBJ_P(obj); - ce = zobj->ce; - clone = ce->clone; - clone_call = zobj->handlers->clone_obj; - if (UNEXPECTED(clone_call == NULL)) { - zend_throw_error(NULL, "Trying to clone an uncloneable object of class %s", ZSTR_VAL(ce->name)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - - if (clone && !(clone->common.fn_flags & ZEND_ACC_PUBLIC)) { - scope = EX(func)->op_array.scope; - ZEND_ASSERT(!(clone->common.fn_flags & ZEND_ACC_PUBLIC)); - if (!zend_check_method_accessible(clone, scope)) { - zend_bad_method_call(clone, clone->common.function_name, scope); + ht = Z_ARRVAL_P(container); + ZEND_HASH_INDEX_FIND(ht, offset, value, fetch_dim_r_index_undef); + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + SAVE_OPLINE(); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + ZEND_VM_NEXT_OPCODE(); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto fetch_dim_r_index_array; + } else { + goto fetch_dim_r_index_slow; + } + } else { +fetch_dim_r_index_slow: + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR|IS_CV) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; } + zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(zobj)); - +fetch_dim_r_index_undef: + ZVAL_NULL(EX_VAR(opline->result.var)); + SAVE_OPLINE(); + zend_undefined_offset(offset); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *expr; - zval *result = EX_VAR(opline->result.var); + zval *op1, *op2; SAVE_OPLINE(); - expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - switch (opline->extended_value) { - case IS_LONG: - ZVAL_LONG(result, zval_get_long(expr)); - break; - case IS_DOUBLE: - ZVAL_DOUBLE(result, zval_get_double(expr)); - break; - case IS_STRING: - ZVAL_STR(result, zval_get_string(expr)); - break; - default: - ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead"); - if (IS_TMP_VAR & (IS_VAR|IS_CV)) { - ZVAL_DEREF(expr); - } - /* If value is already of correct type, return it directly */ - if (Z_TYPE_P(expr) == opline->extended_value) { - ZVAL_COPY_VALUE(result, expr); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); - } else if (IS_TMP_VAR != IS_TMP_VAR) { - if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); - } - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } - - if (opline->extended_value == IS_ARRAY) { - zend_cast_zval_to_array(result, expr, IS_TMP_VAR); - } else { - ZEND_ASSERT(opline->extended_value == IS_OBJECT); - zend_cast_zval_to_object(result, expr, IS_TMP_VAR); - } - } - + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + div_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INCLUDE_OR_EVAL_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_op_array *new_op_array; - zval *inc_filename; + zval *op1, *op2; SAVE_OPLINE(); - inc_filename = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - new_op_array = zend_include_or_eval(inc_filename, opline->extended_value); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (new_op_array != ZEND_FAKE_OP_ARRAY && new_op_array != NULL) { - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - } - UNDEF_RESULT(); - 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 (UNEXPECTED(new_op_array == NULL)) { - if (RETURN_VALUE_USED(opline)) { - ZVAL_FALSE(EX_VAR(opline->result.var)); - } - } else if (new_op_array->last == 1 - && new_op_array->opcodes[0].opcode == ZEND_RETURN - && new_op_array->opcodes[0].op1_type == IS_CONST - && EXPECTED(zend_execute_ex == execute_ex)) { - if (RETURN_VALUE_USED(opline)) { - const zend_op *op = new_op_array->opcodes; - - ZVAL_COPY(EX_VAR(opline->result.var), RT_CONSTANT(op, op->op1)); - } - zend_destroy_static_vars(new_op_array); - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - } else { - zval *return_value = NULL; - zend_execute_data *call; - if (RETURN_VALUE_USED(opline)) { - return_value = EX_VAR(opline->result.var); - } - - new_op_array->scope = EX(func)->op_array.scope; - - call = zend_vm_stack_push_call_frame( - (Z_TYPE_INFO(EX(This)) & ZEND_CALL_HAS_THIS) | ZEND_CALL_NESTED_CODE | ZEND_CALL_HAS_SYMBOL_TABLE, - (zend_function*)new_op_array, 0, - Z_PTR(EX(This))); - - 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); - - - if (EXPECTED(zend_execute_ex == execute_ex)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_ENTER(); - } else { - ZEND_ADD_CALL_FLAG(call, ZEND_CALL_TOP); - zend_execute_ex(call); - zend_vm_stack_free_call_frame(call); - } - - zend_destroy_static_vars(new_op_array); - destroy_op_array(new_op_array); - efree_size(new_op_array, sizeof(zend_op_array)); - if (UNEXPECTED(EG(exception) != NULL)) { - zend_rethrow_exception(execute_data); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + pow_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_R_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *array_ptr, *result; - - SAVE_OPLINE(); - - array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { - result = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(result, array_ptr); - if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { - Z_ADDREF_P(array_ptr); - } - Z_FE_POS_P(result) = 0; - + zval *op1, *op2; - ZEND_VM_NEXT_OPCODE(); - } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { - zend_object *zobj = Z_OBJ_P(array_ptr); - if (!zobj->ce->get_iterator) { - if (UNEXPECTED(zend_object_is_lazy(zobj))) { - zobj = zend_lazy_object_init(zobj); - if (UNEXPECTED(EG(exception))) { - UNDEF_RESULT(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - HANDLE_EXCEPTION(); - } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); } - HashTable *properties = zobj->properties; - if (properties) { - if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) { - if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) { - GC_DELREF(properties); - } - properties = zobj->properties = zend_array_dup(properties); - } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { - properties = zobj->handlers->get_properties(zobj); + ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - - result = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(result, array_ptr); - if (IS_TMP_VAR != IS_TMP_VAR) { - Z_ADDREF_P(array_ptr); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); - if (zend_hash_num_elements(properties) == 0) { - Z_FE_ITER_P(result) = (uint32_t) -1; - - - ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { + zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); + } + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } - - Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } else { - bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } else if (is_empty) { - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); - } else { - ZEND_VM_NEXT_OPCODE(); + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } } + ZEND_VM_NEXT_OPCODE(); } else { - zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; + SAVE_OPLINE(); + + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + op1 = ZVAL_UNDEFINED_OP1(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + op2 = ZVAL_UNDEFINED_OP2(); + } + concat_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_RW_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *array_ptr, *array_ref; - - SAVE_OPLINE(); + zval *op1, *op2; + double d1, d2; - if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - array_ref = array_ptr = zend_get_bad_ptr(); - if (Z_ISREF_P(array_ref)) { - array_ptr = Z_REFVAL_P(array_ref); - } - } else { - array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - } - - if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { - if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - if (array_ptr == array_ref) { - ZVAL_NEW_REF(array_ref, array_ref); - array_ptr = Z_REFVAL_P(array_ref); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); } - Z_ADDREF_P(array_ref); - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); - } else { - array_ref = EX_VAR(opline->result.var); - ZVAL_NEW_REF(array_ref, array_ptr); - array_ptr = Z_REFVAL_P(array_ref); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; } - if (IS_TMP_VAR == IS_CONST) { - ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr))); - } else { - SEPARATE_ARRAY(array_ptr); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; } - Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0); - - - ZEND_VM_NEXT_OPCODE(); - } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { - if (!Z_OBJCE_P(array_ptr)->get_iterator) { - zend_object *zobj = Z_OBJ_P(array_ptr); - HashTable *properties; - if (UNEXPECTED(zend_object_is_lazy(zobj))) { - zobj = zend_lazy_object_init(zobj); - if (UNEXPECTED(EG(exception))) { - UNDEF_RESULT(); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (result) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } + } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - HANDLE_EXCEPTION(); - } + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); } - if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { - if (array_ptr == array_ref) { - ZVAL_NEW_REF(array_ref, array_ref); - array_ptr = Z_REFVAL_P(array_ref); - } - Z_ADDREF_P(array_ref); - ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; } else { - array_ptr = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(array_ptr, array_ref); + goto is_equal_false; } - if (Z_OBJ_P(array_ptr)->properties - && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) { - if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) { - GC_DELREF(Z_OBJ_P(array_ptr)->properties); - } - Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); } - - properties = Z_OBJPROP_P(array_ptr); - if (zend_hash_num_elements(properties) == 0) { - Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1; - - - ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); } - - Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } else if (is_empty) { - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + if (result) { + goto is_equal_true; } else { - ZEND_VM_NEXT_OPCODE(); + goto is_equal_false; } } - } else { - zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_FETCH_R_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *array; - zval *value; - uint32_t value_type; - HashTable *fe_ht; - HashPosition pos; + zval *op1, *op2; + double d1, d2; - array = EX_VAR(opline->op1.var); - if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) { - ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - fe_ht = Z_ARRVAL_P(array); - pos = Z_FE_POS_P(array); - if (HT_IS_PACKED(fe_ht)) { - value = fe_ht->arPacked + pos; - while (1) { - if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { - /* reached end of iteration */ - ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); - ZEND_VM_CONTINUE(); - } - value_type = Z_TYPE_INFO_P(value); - ZEND_ASSERT(value_type != IS_INDIRECT); - if (EXPECTED(value_type != IS_UNDEF)) { - break; + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +is_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + } else { +is_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); } - pos++; - value++; + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_equal_double; } - Z_FE_POS_P(array) = pos + 1; - if (RETURN_VALUE_USED(opline)) { - ZVAL_LONG(EX_VAR(opline->result.var), pos); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_equal_double: + if (d1 == d2) { + goto is_equal_true; + } else { + goto is_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_equal_double; } - } else { - Bucket *p; - - p = fe_ht->arData + pos; - while (1) { - if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { - /* reached end of iteration */ - ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); - ZEND_VM_CONTINUE(); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); } - pos++; - value = &p->val; - value_type = Z_TYPE_INFO_P(value); - ZEND_ASSERT(value_type != IS_INDIRECT); - if (EXPECTED(value_type != IS_UNDEF)) { - break; + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); } - p++; - } - Z_FE_POS_P(array) = pos; - if (RETURN_VALUE_USED(opline)) { - if (!p->key) { - ZVAL_LONG(EX_VAR(opline->result.var), p->h); + if (result) { + goto is_equal_true; } else { - ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key); + goto is_equal_false; } } } - if (EXPECTED(opline->op2_type == IS_CV)) { - zval *variable_ptr = EX_VAR(opline->op2.var); - SAVE_OPLINE(); - zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else { - if (UNEXPECTED(Z_ISREF_P(value))) { - value = Z_REFVAL_P(value); - value_type = Z_TYPE_INFO_P(value); - } - zval *res = EX_VAR(opline->op2.var); - zend_refcounted *gc = Z_COUNTED_P(value); - - ZVAL_COPY_VALUE_EX(res, value, gc, value_type); - if (Z_TYPE_INFO_REFCOUNTED(value_type)) { - GC_ADDREF(gc); - } - ZEND_VM_NEXT_OPCODE(); - } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_END_SILENCE_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *op1, *op2; + double d1, d2; - if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting)) - && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) { - EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var)); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_NONE(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_NONE(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } } - ZEND_VM_NEXT_OPCODE(); + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMP_SET_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; - zend_reference *ref = NULL; - bool ret; - - SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + zval *op1, *op2; + double d1, d2; - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) { - if (IS_TMP_VAR == IS_VAR) { - ref = Z_REF_P(value); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } } - value = Z_REFVAL_P(value); - } - - ret = i_zend_is_true(value); - - if (UNEXPECTED(EG(exception))) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} - if (ret) { - zval *result = EX_VAR(opline->result.var); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; - ZVAL_COPY_VALUE(result, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); - } else if (IS_TMP_VAR == IS_CV) { - if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); - } else if (IS_TMP_VAR == IS_VAR && ref) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(result)) { - Z_ADDREF_P(result); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && (IS_TMP_VAR|IS_VAR) == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { + /* pass */ + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { +is_not_equal_true: + ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); + } else { +is_not_equal_false: + ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +is_not_equal_double: + if (d1 != d2) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto is_not_equal_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op2); + } + if (!result) { + goto is_not_equal_true; + } else { + goto is_not_equal_false; } } - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); } + ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + compare_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COALESCE_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; - zend_reference *ref = NULL; + zval *op1, *op2; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + boolean_xor_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { - if (IS_TMP_VAR & IS_VAR) { - ref = Z_REF_P(value); - } - value = Z_REFVAL_P(value); - } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container, *dim, *value; - if (Z_TYPE_P(value) > IS_NULL) { - zval *result = EX_VAR(opline->result.var); - ZVAL_COPY_VALUE(result, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); - } else if (IS_TMP_VAR == IS_CV) { - if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); - } else if ((IS_TMP_VAR & IS_VAR) && ref) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(result)) { - Z_ADDREF_P(result); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +fetch_dim_r_array: + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC); + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto fetch_dim_r_array; + } else { + goto fetch_dim_r_slow; } + } else { +fetch_dim_r_slow: + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); - } - - if ((IS_TMP_VAR & IS_VAR) && ref) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } + } else { + zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMP_NULL_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *val, *result; - - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + zval *container; - if (Z_TYPE_P(val) > IS_NULL) { + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *container; + void **cache_slot = NULL; + + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) { - val = Z_REFVAL_P(val); - if (Z_TYPE_P(val) <= IS_NULL) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; } } - ZEND_VM_NEXT_OPCODE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + ZVAL_NULL(EX_VAR(opline->result.var)); + goto fetch_obj_r_finish; } while (0); } - result = EX_VAR(opline->result.var); - uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK; - if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { - ZVAL_NULL(result); - if (IS_TMP_VAR == IS_CV - && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF) - && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0 - ) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { - ZVAL_FALSE(result); - } else { - ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); - ZVAL_TRUE(result); - } + /* here we are sure we are dealing with an object */ + do { + zend_object *zobj = Z_OBJ_P(container); + zend_string *name, *tmp_name; + zval *retval; - ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); -} + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_QM_ASSIGN_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - zval *result = EX_VAR(opline->result.var); + if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - ZVAL_NULL(result); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { +fetch_obj_r_simple: + retval = OBJ_PROP(zobj, prop_offset); + if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) { + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { +fetch_obj_r_fast_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); + } + } + } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { + zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { + prop_offset = prop_info->offset; + goto fetch_obj_r_simple; + } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) { + zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET]; + ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION); + ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array)); - if (IS_TMP_VAR == IS_CV) { - ZVAL_COPY_DEREF(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(result, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { - Z_ADDREF_P(result); - } - } - } - ZEND_VM_NEXT_OPCODE(); -} + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if ((IS_TMP_VAR|IS_VAR) & IS_CV) { + GC_ADDREF(zobj); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) { + call_info |= ZEND_CALL_RELEASE_THIS; + } + zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj); + call->prev_execute_data = execute_data; + call->call = NULL; + call->return_value = EX_VAR(opline->result.var); + call->run_time_cache = RUN_TIME_CACHE(&hook->op_array); -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_FROM_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); - zval *val; + execute_data = call; + EG(current_execute_data) = execute_data; + zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); - SAVE_OPLINE(); - val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); +#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) + opline = hook->op_array.opcodes; +#else + EX(opline) = hook->op_array.opcodes; +#endif + LOAD_OPLINE_EX(); - if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) { - zend_throw_error(NULL, "Cannot use \"yield from\" in a force-closed generator"); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } -yield_from_try_again: - if (Z_TYPE_P(val) == IS_ARRAY) { - ZVAL_COPY_VALUE(&generator->values, val); - if (Z_OPT_REFCOUNTED_P(val)) { - Z_ADDREF_P(val); - } - Z_FE_POS(generator->values) = 0; - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } else if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(val) == IS_OBJECT && Z_OBJCE_P(val)->get_iterator) { - zend_class_entry *ce = Z_OBJCE_P(val); - if (ce == zend_ce_generator) { - zend_generator *new_gen = (zend_generator *) Z_OBJ_P(val); - Z_ADDREF_P(val); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - if (UNEXPECTED(new_gen->execute_data == NULL)) { - zend_throw_error(NULL, "Generator passed to yield from was aborted without proper return and is unable to continue"); - zval_ptr_dtor(val); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } else if (Z_ISUNDEF(new_gen->retval)) { - if (UNEXPECTED(zend_generator_get_current(new_gen) == generator)) { - zend_throw_error(NULL, "Impossible to yield from the Generator being currently run"); - zval_ptr_dtor(val); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } else { - zend_generator_yield_from(generator, new_gen); - } - } else { - if (RETURN_VALUE_USED(opline)) { - ZVAL_COPY(EX_VAR(opline->result.var), &new_gen->retval); - } - ZEND_VM_NEXT_OPCODE(); - } - } else { - zend_object_iterator *iter = ce->get_iterator(ce, val, 0); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_ENTER_EX(); + } + /* Fall through to read_property for hooks. */ + } else if (EXPECTED(zobj->properties != NULL)) { + ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { + uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); - if (UNEXPECTED(!iter) || UNEXPECTED(EG(exception))) { - if (!EG(exception)) { - zend_throw_error(NULL, "Object of type %s did not create an Iterator", ZSTR_VAL(ce->name)); - } - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } + if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { + Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); - iter->index = 0; - if (iter->funcs->rewind) { - iter->funcs->rewind(iter); - if (UNEXPECTED(EG(exception) != NULL)) { - OBJ_RELEASE(&iter->std); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); + if (EXPECTED(p->key == name) || + (EXPECTED(p->h == ZSTR_H(name)) && + EXPECTED(p->key != NULL) && + EXPECTED(zend_string_equal_content(p->key, name)))) { + retval = &p->val; + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { + goto fetch_obj_r_fast_copy; + } + } + } + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); + } + retval = zend_hash_find_known_hash(zobj->properties, name); + if (EXPECTED(retval)) { + uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { + goto fetch_obj_r_fast_copy; + } + } } } - - ZVAL_OBJ(&generator->values, &iter->std); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + break; + } } - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(val) == IS_REFERENCE) { - val = Z_REFVAL_P(val); - goto yield_from_try_again; - } else { - zend_throw_error(NULL, "Can use \"yield from\" only with arrays and Traversables"); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - UNDEF_RESULT(); - HANDLE_EXCEPTION(); - } - /* This is the default return value - * when the expression is a Generator, it will be overwritten in zend_generator_resume() */ - if (RETURN_VALUE_USED(opline)) { - ZVAL_NULL(EX_VAR(opline->result.var)); - } +#if ZEND_DEBUG + /* For non-standard object handlers, verify a declared property type in debug builds. + * Fetch prop_info before calling read_property(), as it may deallocate the object. */ + zend_property_info *prop_info = NULL; + if (zobj->handlers->read_property != zend_std_read_property) { + prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true); + } +#endif + retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var)); +#if ZEND_DEBUG + if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO + && ZEND_TYPE_IS_SET(prop_info->type)) { + ZVAL_OPT_DEREF(retval); + zend_verify_property_type(prop_info, retval, /* strict */ true); + } +#endif - /* This generator has no send target (though the generator we delegate to might have one) */ - generator->send_target = NULL; + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - /* The GOTO VM uses a local opline variable. We need to set the opline - * variable in execute_data so we don't resume at an old position. */ - SAVE_OPLINE(); + if (retval != EX_VAR(opline->result.var)) { +fetch_obj_r_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_unwrap_reference(retval); + } + } while (0); - ZEND_VM_RETURN(); +fetch_obj_r_finish: + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_STRLEN_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *value; - - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(value); - } - ZEND_VM_NEXT_OPCODE(); - } else { - bool strict; + zval *container; + void **cache_slot = NULL; - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(value) == IS_REFERENCE) { - value = Z_REFVAL_P(value); - if (EXPECTED(Z_TYPE_P(value) == IS_STRING)) { - ZVAL_LONG(EX_VAR(opline->result.var), Z_STRLEN_P(value)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE(); - } - } + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - value = ZVAL_UNDEFINED_OP1(); - } - strict = EX_USES_STRICT_TYPES(); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if (EXPECTED(!strict)) { - zend_string *str; - zval tmp; - - if (UNEXPECTED(Z_TYPE_P(value) == IS_NULL)) { - zend_error(E_DEPRECATED, - "strlen(): Passing null to parameter #1 ($string) of type string is deprecated"); - ZVAL_LONG(EX_VAR(opline->result.var), 0); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - break; - } - - ZVAL_COPY(&tmp, value); - if (zend_parse_arg_str_weak(&tmp, &str, 1)) { - ZVAL_LONG(EX_VAR(opline->result.var), ZSTR_LEN(str)); - zval_ptr_dtor(&tmp); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; } - zval_ptr_dtor(&tmp); } - if (!EG(exception)) { - zend_type_error("strlen(): Argument #1 ($string) must be of type string, %s given", zend_zval_value_name(value)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + ZVAL_UNDEFINED_OP2(); } - ZVAL_UNDEF(EX_VAR(opline->result.var)); + ZVAL_NULL(EX_VAR(opline->result.var)); + goto fetch_obj_is_finish; } while (0); } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} -static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_TYPE_CHECK_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - int result = 0; + /* here we are sure we are dealing with an object */ + do { + zend_object *zobj = Z_OBJ_P(container); + zend_string *name, *tmp_name; + zval *retval; - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { -type_check_resource: - if (opline->extended_value != MAY_BE_RESOURCE - || EXPECTED(NULL != zend_rsrc_list_get_rsrc_type(Z_RES_P(value)))) { - result = 1; - } - } else if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - if ((opline->extended_value >> (uint32_t)Z_TYPE_P(value)) & 1) { - goto type_check_resource; - } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - result = ((1 << IS_NULL) & opline->extended_value) != 0; - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception))) { - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - SAVE_OPLINE(); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); - } else { - ZEND_VM_SMART_BRANCH(result, 0); - } -} + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + cache_slot = CACHE_ADDR(opline->extended_value); -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_NAME_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - uint32_t fetch_type; - zend_class_entry *called_scope, *scope; - USE_OPLINE + if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); - if (IS_TMP_VAR != IS_UNUSED) { - SAVE_OPLINE(); - zval *op = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (UNEXPECTED(Z_TYPE_P(op) != IS_OBJECT)) { - ZVAL_DEREF(op); - if (Z_TYPE_P(op) != IS_OBJECT) { - zend_type_error("Cannot use \"::class\" on %s", zend_zval_value_name(op)); + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { +fetch_obj_is_simple: + retval = OBJ_PROP(zobj, prop_offset); + if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) { + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { +fetch_obj_is_fast_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); + } + } + } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { + zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + goto fetch_obj_is_simple; + } + /* Fall through to read_property for hooks. */ + } else if (EXPECTED(zobj->properties != NULL)) { + ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { + uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + + if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { + Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + + if (EXPECTED(p->key == name) || + (EXPECTED(p->h == ZSTR_H(name)) && + EXPECTED(p->key != NULL) && + EXPECTED(zend_string_equal_content(p->key, name)))) { + retval = &p->val; + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { + goto fetch_obj_is_fast_copy; + } + } + } + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); + } + retval = zend_hash_find_known_hash(zobj->properties, name); + if (EXPECTED(retval)) { + uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { + goto fetch_obj_is_fast_copy; + } + } + } + } + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + break; } } - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op)->name); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } + retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - fetch_type = opline->op1.num; - scope = EX(func)->op_array.scope; - if (UNEXPECTED(scope == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, "Cannot use \"%s\" in the global scope", - fetch_type == ZEND_FETCH_CLASS_SELF ? "self" : - fetch_type == ZEND_FETCH_CLASS_PARENT ? "parent" : "static"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } - switch (fetch_type) { - case ZEND_FETCH_CLASS_SELF: - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->name); - break; - case ZEND_FETCH_CLASS_PARENT: - if (UNEXPECTED(scope->parent == NULL)) { - SAVE_OPLINE(); - zend_throw_error(NULL, - "Cannot use \"parent\" when current class scope has no parent"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - ZVAL_STR_COPY(EX_VAR(opline->result.var), scope->parent->name); - break; - case ZEND_FETCH_CLASS_STATIC: - if (Z_TYPE(EX(This)) == IS_OBJECT) { - called_scope = Z_OBJCE(EX(This)); - } else { - called_scope = Z_CE(EX(This)); - } - ZVAL_STR_COPY(EX_VAR(opline->result.var), called_scope->name); - break; - EMPTY_SWITCH_DEFAULT_CASE() - } - ZEND_VM_NEXT_OPCODE(); + if (retval != EX_VAR(opline->result.var)) { +fetch_obj_is_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_unwrap_reference(retval); + } + } while (0); + +fetch_obj_is_finish: + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - div_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - pow_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zend_string *op1_str, *op2_str, *str; - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { size_t len = ZSTR_LEN(op1_str); - if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { - zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); - } str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -70822,547 +74298,913 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_TMP_CO memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } ZEND_VM_NEXT_OPCODE(); - } else { - SAVE_OPLINE(); + } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - op1 = ZVAL_UNDEFINED_OP1(); + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + op1_str = Z_STR_P(op1); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + op1_str = zend_string_copy(Z_STR_P(op1)); + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - op2 = ZVAL_UNDEFINED_OP2(); + op1_str = zval_get_string_func(op1); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + op2_str = Z_STR_P(op2); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + op2_str = zend_string_copy(Z_STR_P(op2)); + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); } - concat_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + op2_str = zval_get_string_func(op2); } -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { + GC_ADDREF(op2_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + zend_string_release_ex(op1_str, 0); + break; + } + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { + GC_ADDREF(op1_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + zend_string_release_ex(op2_str, 0); + break; + } + } + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - result = fast_is_identical_function(op1, op2); + ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_string_release_ex(op1_str, 0); + } + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_string_release_ex(op2_str, 0); + } + } while (0); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_SMART_BRANCH(result, 1); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - bool result; + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - result = fast_is_identical_function(op1, op2); + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - ZEND_VM_SMART_BRANCH(result, 1); -} + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); + } - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - result = fast_is_not_identical_function(op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + obj = Z_OBJ_P(object); + } else { + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + } else { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + zend_reference *ref = Z_REF_P(object); + object = &ref->val; + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else { + Z_ADDREF_P(object); + } + } + break; + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + HANDLE_EXCEPTION(); + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + } + zend_invalid_method_call(object, function_name); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } while (0); + } - ZEND_VM_SMART_BRANCH(result, 1); -} + called_scope = obj->ce; -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + HANDLE_EXCEPTION(); + } + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + GC_ADDREF(obj); /* For $this pointer */ + if (GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } + } + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { + zend_objects_store_del(obj); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); } } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); +case_true: + ZEND_VM_SMART_BRANCH_TRUE(); } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); +case_false: + ZEND_VM_SMART_BRANCH_FALSE(); } } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = (double)Z_LVAL_P(op1); d2 = Z_DVAL_P(op2); - goto is_equal_double; + goto case_double; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { d1 = Z_DVAL_P(op1); d2 = Z_DVAL_P(op2); -is_equal_double: +case_double: if (d1 == d2) { - goto is_equal_true; + goto case_true; } else { - goto is_equal_false; + goto case_false; } } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { d1 = Z_DVAL_P(op1); d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; + goto case_double; } } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (result) { - goto is_equal_true; + goto case_true; } else { - goto is_equal_false; + goto case_false; } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *container; + bool result; + zend_ulong hval; + zval *offset; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + HashTable *ht; + zval *value; + zend_string *str; + +isset_dim_obj_array: + ht = Z_ARRVAL_P(container); +isset_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index_prop; + } } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; + value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index_prop: + value = zend_hash_index_find(ht, hval); + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + offset = Z_REFVAL_P(offset); + goto isset_again; + } else { + value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); + if (UNEXPECTED(EG(exception))) { + result = 0; + goto isset_dim_obj_exit; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; + + if (!(opline->extended_value & ZEND_ISEMPTY)) { + /* > IS_NULL means not IS_UNDEF and not IS_NULL */ + result = value != NULL && Z_TYPE_P(value) > IS_NULL && + (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); + + if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { + /* avoid exception check */ + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 0); } + } else { + result = (value == NULL || !i_zend_is_true(value)); + } + goto isset_dim_obj_exit; + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto isset_dim_obj_array; } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + offset++; + } + if (!(opline->extended_value & ZEND_ISEMPTY)) { + result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); + } else { + result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); + } + +isset_dim_obj_exit: + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *container; + int result; + zval *offset; + zend_string *name, *tmp_name; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; + } else { + result = (opline->extended_value & ZEND_ISEMPTY); + goto isset_object_finish; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; - } + } + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + name = Z_STR_P(offset); + } else { + name = zval_try_get_tmp_string(offset, &tmp_name); + if (UNEXPECTED(!name)) { + result = 0; + goto isset_object_finish; } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + result = + (opline->extended_value & ZEND_ISEMPTY) ^ + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +isset_object_finish: + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + zval *key, *subject; + HashTable *ht; + bool result; + + SAVE_OPLINE(); + + key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { +array_key_exists_array: + ht = Z_ARRVAL_P(subject); + result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); + } else { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + subject = Z_REFVAL_P(subject); + if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { + goto array_key_exists_array; } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); + zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); + result = 0; + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + bool result; + + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + +try_instanceof: + if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; + + if (IS_VAR == IS_CONST) { + ce = CACHED_PTR(cache_slot); + if (UNEXPECTED(ce == NULL)) { + ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); + if (EXPECTED(ce)) { + CACHE_PTR(cache_slot, ce); + } } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + } else if (IS_VAR == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + } else { + ce = Z_CE_P(EX_VAR(opline->op2.var)); + } + result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_VAR == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; } + /* If no expected_args, just check the base class (already done) */ + } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { + expr = Z_REFVAL_P(expr); + goto try_instanceof; + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } + result = 0; } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_EX int type); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + int fetch_type = + (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ? + BP_VAR_W : BP_VAR_R; + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type)); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *value, *arg; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (1 && IS_TMP_VAR == IS_CONST && IS_CONST == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; + if (IS_UNUSED == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + uint32_t arg_num; + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; - } + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + } + + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; + zval *varname; + zend_string *name, *tmp_name; + HashTable *target_symbol_table; SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - compare_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + name = Z_STR_P(varname); + } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { + name = Z_STR_P(varname); + tmp_name = NULL; + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { + varname = ZVAL_UNDEFINED_OP1(); + } + name = zval_try_get_tmp_string(varname, &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + + target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); + zend_hash_del_ind(target_symbol_table, name); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_XOR_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; + zval *value; + bool result; + zval *varname; + zend_string *name, *tmp_name; + HashTable *target_symbol_table; SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - boolean_xor_function(EX_VAR(opline->result.var), op1, op2); + varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + name = Z_STR_P(varname); + } else { + name = zval_get_tmp_string(varname, &tmp_name); + } + + target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); + value = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (!value) { + result = (opline->extended_value & ZEND_ISEMPTY); + } else { + if (Z_TYPE_P(value) == IS_INDIRECT) { + value = Z_INDIRECT_P(value); + } + if (!(opline->extended_value & ZEND_ISEMPTY)) { + if (Z_ISREF_P(value)) { + value = Z_REFVAL_P(value); + } + result = Z_TYPE_P(value) > IS_NULL; + } else { + result = !i_zend_is_true(value); + } + } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_SMART_BRANCH(result, true); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { -#if 0 USE_OPLINE -#endif + zval *expr; + bool result; - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + +try_instanceof: + if (Z_TYPE_P(expr) == IS_OBJECT) { + zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; + + if (IS_UNUSED == IS_CONST) { + ce = CACHED_PTR(cache_slot); + if (UNEXPECTED(ce == NULL)) { + ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); + if (EXPECTED(ce)) { + CACHE_PTR(cache_slot, ce); + } + } + } else if (IS_UNUSED == IS_UNUSED) { + ce = zend_fetch_class(NULL, opline->op2.num); + if (UNEXPECTED(ce == NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + } else { + ce = Z_CE_P(EX_VAR(opline->op2.var)); } - ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_UNUSED == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { + expr = Z_REFVAL_P(expr); + goto try_instanceof; } else { - if (IS_CONST == IS_UNUSED) { - ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); + result = 0; + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COUNT_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1; + zend_long count; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + while (1) { + if (Z_TYPE_P(op1) == IS_ARRAY) { + count = zend_hash_num_elements(Z_ARRVAL_P(op1)); + break; + } else if (Z_TYPE_P(op1) == IS_OBJECT) { + zend_object *zobj = Z_OBJ_P(op1); + + /* first, we check if the handler is defined */ + if (zobj->handlers->count_elements) { + if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) { + break; + } + if (UNEXPECTED(EG(exception))) { + count = 0; + break; + } + } + + /* if not and the object implements Countable we call its count() method */ + if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) { + zval retval; + + zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT)); + zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval); + count = zval_get_long(&retval); + zval_ptr_dtor(&retval); + break; } + + /* If There's no handler and it doesn't implement Countable then emit a TypeError */ + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + continue; + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + count = 0; + zend_type_error("%s(): Argument #1 ($value) must be of type Countable|array, %s given", opline->extended_value ? "sizeof" : "count", zend_zval_value_name(op1)); + break; } + + ZVAL_LONG(EX_VAR(opline->result.var), count); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { -#if 0 USE_OPLINE -#endif + zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC)); + ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht)); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + SAVE_OPLINE(); + zend_array_destroy(ht); + if (EG(exception)) { + HANDLE_EXCEPTION(); + } + } + ZEND_VM_NEXT_OPCODE(); +} - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - /* Behave like FETCH_OBJ_W */ - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + SAVE_OPLINE(); + if (UNEXPECTED(!EX(func)->common.scope)) { + zend_throw_error(NULL, "get_class() without arguments must be called from within a class"); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } else { + zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); + ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + ZEND_VM_NEXT_OPCODE(); } - ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); + zval *op1; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + while (1) { + if (Z_TYPE_P(op1) == IS_OBJECT) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + continue; + } else { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); } + break; } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + zval *result = EX_VAR(opline->result.var); + ZVAL_COPY(result, value); + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; - zend_string *op1_str, *op2_str, *str; + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + div_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_CONST == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + pow_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = EX_VAR(opline->op2.var); + + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CONST == IS_CONST || IS_CONST == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CV == IS_CONST || IS_CV == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_CONST != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { size_t len = ZSTR_LEN(op1_str); + if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { + zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); + } str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -71371,561 +75213,728 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_T memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_CONST & (IS_TMP_VAR|IS_VAR)) { + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } ZEND_VM_NEXT_OPCODE(); - } - - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CONST) { - op1_str = Z_STR_P(op1); - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - op1_str = zend_string_copy(Z_STR_P(op1)); } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); + SAVE_OPLINE(); + + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + op1 = ZVAL_UNDEFINED_OP1(); } - op1_str = zval_get_string_func(op1); - } - if (IS_CONST == IS_CONST) { - op2_str = Z_STR_P(op2); - } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - op2_str = zend_string_copy(Z_STR_P(op2)); - } else { - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + op2 = ZVAL_UNDEFINED_OP2(); } - op2_str = zval_get_string_func(op2); + concat_function(EX_VAR(opline->result.var), op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - do { - if (IS_TMP_VAR != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CONST == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { - GC_ADDREF(op2_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - zend_string_release_ex(op1_str, 0); - break; - } - } - if (IS_CONST != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { - GC_ADDREF(op1_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - zend_string_release_ex(op2_str, 0); - break; - } - } - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); +} - ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR != IS_CONST) { - zend_string_release_ex(op1_str, 0); - } - if (IS_CONST != IS_CONST) { - zend_string_release_ex(op2_str, 0); - } - } while (0); +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + compare_function(EX_VAR(opline->result.var), op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_ADD_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_string **rope; - zval *var; + zval *container, *dim, *value; - /* op1 and result are the same */ - rope = (zend_string**)EX_VAR(opline->op1.var); - if (IS_CONST == IS_CONST) { - var = RT_CONSTANT(opline, opline->op2); - rope[opline->extended_value] = Z_STR_P(var); - if (UNEXPECTED(Z_REFCOUNTED_P(var))) { - Z_ADDREF_P(var); - } - } else { - var = RT_CONSTANT(opline, opline->op2); - if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_CONST == IS_CV) { - rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + dim = EX_VAR(opline->op2.var); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { +fetch_dim_r_array: + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC); + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { + goto fetch_dim_r_array; } else { - rope[opline->extended_value] = Z_STR_P(var); + goto fetch_dim_r_slow; } } else { - SAVE_OPLINE(); - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); +fetch_dim_r_slow: + if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; } - rope[opline->extended_value] = zval_get_string_func(var); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } + } else { + zend_fetch_dimension_address_read_R(container, dim, IS_CV OPLINE_CC EXECUTE_DATA_CC); } - ZEND_VM_NEXT_OPCODE(); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_END_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zend_string **rope; - zval *var, *ret; - uint32_t i; - - rope = (zend_string**)EX_VAR(opline->op1.var); - if (IS_CONST == IS_CONST) { - var = RT_CONSTANT(opline, opline->op2); - rope[opline->extended_value] = Z_STR_P(var); - if (UNEXPECTED(Z_REFCOUNTED_P(var))) { - Z_ADDREF_P(var); - } - } else { - var = RT_CONSTANT(opline, opline->op2); - if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_CONST == IS_CV) { - rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); - } else { - rope[opline->extended_value] = Z_STR_P(var); - } - } else { - SAVE_OPLINE(); - if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - } - rope[opline->extended_value] = zval_get_string_func(var); - - - if (UNEXPECTED(EG(exception))) { - for (i = 0; i <= opline->extended_value; i++) { - zend_string_release_ex(rope[i], 0); - } - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } - } + zval *container; - size_t len = 0; - uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES; - for (i = 0; i <= opline->extended_value; i++) { - flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]); - len += ZSTR_LEN(rope[i]); - } - ret = EX_VAR(opline->result.var); - ZVAL_STR(ret, zend_string_alloc(len, 0)); - GC_ADD_FLAGS(Z_STR_P(ret), flags); + SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC); - char *target = Z_STRVAL_P(ret); - for (i = 0; i <= opline->extended_value; i++) { - memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i])); - target += ZSTR_LEN(rope[i]); - zend_string_release_ex(rope[i], 0); - } - *target = '\0'; - ZEND_VM_NEXT_OPCODE(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; + zval *container; + void **cache_slot = NULL; SAVE_OPLINE(); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - object = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - if (IS_CONST != IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - - if (IS_CONST != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CONST & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; } - } else if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } } - zend_throw_error(NULL, "Method name must be a string"); - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + zend_wrong_property_read(container, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + ZVAL_NULL(EX_VAR(opline->result.var)); + goto fetch_obj_r_finish; } while (0); } - if (IS_TMP_VAR == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); + /* here we are sure we are dealing with an object */ + do { + zend_object *zobj = Z_OBJ_P(container); + zend_string *name, *tmp_name; + zval *retval; - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_TMP_VAR & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CONST != IS_CONST) { + if (IS_CV == IS_CONST) { + cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); + if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { +fetch_obj_r_simple: + retval = OBJ_PROP(zobj, prop_offset); + if (EXPECTED(Z_TYPE_INFO_P(retval) != IS_UNDEF)) { + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { +fetch_obj_r_fast_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); } - HANDLE_EXCEPTION(); } - } - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - zend_invalid_method_call(object, function_name); + } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { + zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { + prop_offset = prop_info->offset; + goto fetch_obj_r_simple; + } else if (EXPECTED(ZEND_IS_PROPERTY_HOOK_SIMPLE_GET(prop_offset))) { + zend_function *hook = prop_info->hooks[ZEND_PROPERTY_HOOK_GET]; + ZEND_ASSERT(hook->type == ZEND_USER_FUNCTION); + ZEND_ASSERT(RUN_TIME_CACHE(&hook->op_array)); + uint32_t call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if ((IS_TMP_VAR|IS_VAR) & IS_CV) { + GC_ADDREF(zobj); + } + if ((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR|IS_TMP_VAR)) { + call_info |= ZEND_CALL_RELEASE_THIS; + } + zend_execute_data *call = zend_vm_stack_push_call_frame(call_info, hook, 0, zobj); + call->prev_execute_data = execute_data; + call->call = NULL; + call->return_value = EX_VAR(opline->result.var); + call->run_time_cache = RUN_TIME_CACHE(&hook->op_array); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } while (0); - } + execute_data = call; + EG(current_execute_data) = execute_data; + zend_init_cvs(0, hook->op_array.last_var EXECUTE_DATA_CC); - called_scope = obj->ce; +#if defined(ZEND_VM_IP_GLOBAL_REG) && ((ZEND_VM_KIND == ZEND_VM_KIND_CALL) || (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)) + opline = hook->op_array.opcodes; +#else + EX(opline) = hook->op_array.opcodes; +#endif + LOAD_OPLINE_EX(); - if (IS_CONST == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - if (IS_CONST == IS_CONST) { - function_name = RT_CONSTANT(opline, opline->op2); - } - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); - } + ZEND_VM_ENTER_EX(); + } + /* Fall through to read_property for hooks. */ + } else if (EXPECTED(zobj->properties != NULL)) { + ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { + uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + + if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { + Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); + if (EXPECTED(p->key == name) || + (EXPECTED(p->h == ZSTR_H(name)) && + EXPECTED(p->key != NULL) && + EXPECTED(zend_string_equal_content(p->key, name)))) { + retval = &p->val; + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { + goto fetch_obj_r_fast_copy; + } + } + } + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); + } + retval = zend_hash_find_known_hash(zobj->properties, name); + if (EXPECTED(retval)) { + uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_r_copy; + } else { + goto fetch_obj_r_fast_copy; + } + } + } } - HANDLE_EXCEPTION(); - } - if (IS_CONST == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + break; } } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - } - } - - if (IS_CONST != IS_CONST) { - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } +#if ZEND_DEBUG + /* For non-standard object handlers, verify a declared property type in debug builds. + * Fetch prop_info before calling read_property(), as it may deallocate the object. */ + zend_property_info *prop_info = NULL; + if (zobj->handlers->read_property != zend_std_read_property) { + prop_info = zend_get_property_info(zobj->ce, name, /* silent */ true); } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_TMP_VAR == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ +#endif + retval = zobj->handlers->read_property(zobj, name, BP_VAR_R, cache_slot, EX_VAR(opline->result.var)); +#if ZEND_DEBUG + if (!EG(exception) && prop_info && prop_info != ZEND_WRONG_PROPERTY_INFO + && ZEND_TYPE_IS_SET(prop_info->type)) { + ZVAL_OPT_DEREF(retval); + zend_verify_property_type(prop_info, retval, /* strict */ true); } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAL_EX_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value, *arg; - uint32_t arg_num; +#endif - if (IS_CONST == IS_CONST) { - SAVE_OPLINE(); - zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); - arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); - if (UNEXPECTED(!arg)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); } - } else { - arg = ZEND_CALL_VAR(EX(call), opline->result.var); - arg_num = opline->op2.num; - } - if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { - if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { - goto send_val_by_ref; - } - } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { -send_val_by_ref:; - ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg)); - } - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - ZVAL_COPY_VALUE(arg, value); - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { - Z_ADDREF_P(arg); + if (retval != EX_VAR(opline->result.var)) { +fetch_obj_r_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_unwrap_reference(retval); } - } - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; + } while (0); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = RT_CONSTANT(opline, opline->op2); - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -case_true: - ZEND_VM_SMART_BRANCH_TRUE(); - } else { -case_false: - ZEND_VM_SMART_BRANCH_FALSE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -case_double: - if (d1 == d2) { - goto case_true; - } else { - goto case_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); +fetch_obj_r_finish: - if (result) { - goto case_true; - } else { - goto case_false; - } - } - } - ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *expr_ptr, new_expr; + zval *container; + void **cache_slot = NULL; SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && - UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { - expr_ptr = zend_get_bad_ptr(); - if (Z_ISREF_P(expr_ptr)) { - Z_ADDREF_P(expr_ptr); - } else { - ZVAL_MAKE_REF_EX(expr_ptr, 2); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - } else { - expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_TMP_VAR) { - /* pass */ - } else if (IS_TMP_VAR == IS_CONST) { - Z_TRY_ADDREF_P(expr_ptr); - } else if (IS_TMP_VAR == IS_CV) { - ZVAL_DEREF(expr_ptr); - Z_TRY_ADDREF_P(expr_ptr); - } else /* if (IS_TMP_VAR == IS_VAR) */ { - if (UNEXPECTED(Z_ISREF_P(expr_ptr))) { - zend_refcounted *ref = Z_COUNTED_P(expr_ptr); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - expr_ptr = Z_REFVAL_P(expr_ptr); - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - ZVAL_COPY_VALUE(&new_expr, expr_ptr); - expr_ptr = &new_expr; - efree_size(ref, sizeof(zend_reference)); - } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) { - Z_ADDREF_P(expr_ptr); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + do { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + container = Z_REFVAL_P(container); + if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { + break; } } - } + if (IS_CV == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + ZVAL_UNDEFINED_OP2(); + } + ZVAL_NULL(EX_VAR(opline->result.var)); + goto fetch_obj_is_finish; + } while (0); } - if (IS_CONST != IS_UNUSED) { - zval *offset = RT_CONSTANT(opline, opline->op2); - zend_string *str; - zend_ulong hval; + /* here we are sure we are dealing with an object */ + do { + zend_object *zobj = Z_OBJ_P(container); + zend_string *name, *tmp_name; + zval *retval; -add_again: - if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - if (IS_CONST != IS_CONST) { - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index; + if (IS_CV == IS_CONST) { + cache_slot = CACHE_ADDR(opline->extended_value); + + if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { +fetch_obj_is_simple: + retval = OBJ_PROP(zobj, prop_offset); + if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) { + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { +fetch_obj_is_fast_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + ZEND_VM_NEXT_OPCODE(); + } + } + } else if (UNEXPECTED(IS_HOOKED_PROPERTY_OFFSET(prop_offset))) { + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_READ(prop_offset)) { + zend_property_info *prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + goto fetch_obj_is_simple; + } + /* Fall through to read_property for hooks. */ + } else if (EXPECTED(zobj->properties != NULL)) { + ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { + uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); + + if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) { + Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx); + + if (EXPECTED(p->key == name) || + (EXPECTED(p->h == ZSTR_H(name)) && + EXPECTED(p->key != NULL) && + EXPECTED(zend_string_equal_content(p->key, name)))) { + retval = &p->val; + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { + goto fetch_obj_is_fast_copy; + } + } + } + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET); + } + retval = zend_hash_find_known_hash(zobj->properties, name); + if (EXPECTED(retval)) { + uintptr_t idx = (char*)retval - (char*)zobj->properties->arData; + CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx)); + if (0 || ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) != 0) { + goto fetch_obj_is_copy; + } else { + goto fetch_obj_is_fast_copy; + } + } } } -str_index: - zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index: - zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { - offset = Z_REFVAL_P(offset); - goto add_again; - } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { - zval tmp; - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - ZVAL_COPY(&tmp, expr_ptr); + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + ZVAL_UNDEF(EX_VAR(opline->result.var)); + break; } - zend_error(E_DEPRECATED, "Using null as an array offset is deprecated, use an empty string instead"); - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { - /* A userland error handler can do funky things to the expression, so reset it */ - zval_ptr_dtor(expr_ptr); - ZVAL_COPY_VALUE(expr_ptr, &tmp); + } + + retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); + + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + + if (retval != EX_VAR(opline->result.var)) { +fetch_obj_is_copy: + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), retval); + } else if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_unwrap_reference(retval); + } + } while (0); + +fetch_obj_is_finish: + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + zend_string *op1_str, *op2_str, *str; + + + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = EX_VAR(opline->op2.var); + if (((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && + (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + zend_string *op1_str = Z_STR_P(op1); + zend_string *op2_str = Z_STR_P(op2); + zend_string *str; + uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CV == IS_CONST || IS_CV == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op2_str); } - if (UNEXPECTED(EG(exception))) { - zval_ptr_dtor_nogc(expr_ptr); - HANDLE_EXCEPTION(); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { + ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); + } else { + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + } + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && (IS_TMP_VAR|IS_VAR) != IS_CV && + !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { + size_t len = ZSTR_LEN(op1_str); + + str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); } - str = ZSTR_EMPTY_ALLOC(); - goto str_index; - } else if (Z_TYPE_P(offset) == IS_DOUBLE) { - hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); - goto num_index; - } else if (Z_TYPE_P(offset) == IS_FALSE) { - hval = 0; - goto num_index; - } else if (Z_TYPE_P(offset) == IS_TRUE) { - hval = 1; - goto num_index; - } else if (Z_TYPE_P(offset) == IS_RESOURCE) { - zend_use_resource_as_offset(offset); - hval = Z_RES_HANDLE_P(offset); - goto num_index; - } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { - ZVAL_UNDEFINED_OP2(); - str = ZSTR_EMPTY_ALLOC(); - goto str_index; } else { - zend_illegal_array_offset_access(offset); - zval_ptr_dtor_nogc(expr_ptr); + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + GC_ADD_FLAGS(str, flags); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CV & (IS_TMP_VAR|IS_VAR)) { + zend_string_release_ex(op2_str, 0); + } } + ZEND_VM_NEXT_OPCODE(); + } - + SAVE_OPLINE(); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + op1_str = Z_STR_P(op1); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + op1_str = zend_string_copy(Z_STR_P(op1)); } else { - if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_cannot_add_element(); - zval_ptr_dtor_nogc(expr_ptr); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + op1_str = zval_get_string_func(op1); + } + if (IS_CV == IS_CONST) { + op2_str = Z_STR_P(op2); + } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + op2_str = zend_string_copy(Z_STR_P(op2)); + } else { + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); } + op2_str = zval_get_string_func(op2); } + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { + if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { + GC_ADDREF(op2_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op2_str); + zend_string_release_ex(op1_str, 0); + break; + } + } + if (IS_CV != IS_CONST) { + if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { + GC_ADDREF(op1_str); + } + } + ZVAL_STR(EX_VAR(opline->result.var), op1_str); + zend_string_release_ex(op2_str, 0); + break; + } + } + str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); + memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); + memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); + + ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); + ZVAL_NEW_STR(EX_VAR(opline->result.var), str); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_string_release_ex(op1_str, 0); + } + if (IS_CV != IS_CONST) { + zend_string_release_ex(op2_str, 0); + } + } while (0); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - zval *array; - uint32_t size; USE_OPLINE + zval *function_name; + zval *object; + zend_function *fbc; + zend_class_entry *called_scope; + zend_object *obj; + zend_execute_data *call; + uint32_t call_info; SAVE_OPLINE(); - array = EX_VAR(opline->result.var); - if (IS_TMP_VAR != IS_UNUSED) { - size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; - ZVAL_ARR(array, zend_new_array(size)); - /* Explicitly initialize array as not-packed if flag is set */ - if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { - zend_hash_real_init_mixed(Z_ARRVAL_P(array)); - } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + + object = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (IS_CV != IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + if (IS_CV != IS_CONST && + UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { + do { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + function_name = Z_REFVAL_P(function_name); + if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { + break; + } + } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + if (UNEXPECTED(EG(exception) != NULL)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + zend_throw_error(NULL, "Method name must be a string"); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } while (0); + } + + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + obj = Z_OBJ_P(object); } else { - ZVAL_ARR(array, zend_new_array(0)); - ZEND_VM_NEXT_OPCODE(); + do { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + } else { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { + zend_reference *ref = Z_REF_P(object); + + object = &ref->val; + if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { + obj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) & IS_VAR) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else { + Z_ADDREF_P(object); + } + } + break; + } + } + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { + object = ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + if (IS_CV != IS_CONST) { + + + } + HANDLE_EXCEPTION(); + } + } + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + zend_invalid_method_call(object, function_name); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } while (0); + } + + called_scope = obj->ce; + + if (IS_CV == IS_CONST && + EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { + fbc = CACHED_PTR(opline->result.num + sizeof(void*)); + } else { + zend_object *orig_obj = obj; + + if (IS_CV == IS_CONST) { + function_name = EX_VAR(opline->op2.var); + } + + /* First, locate the function. */ + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + if (UNEXPECTED(fbc == NULL)) { + if (EXPECTED(!EG(exception))) { + zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); + } + + + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); + } + HANDLE_EXCEPTION(); + } + if (IS_CV == IS_CONST && + EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && + EXPECTED(obj == orig_obj)) { + CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); + } + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { + GC_ADDREF(obj); /* For $this pointer */ + if (GC_DELREF(orig_obj) == 0) { + zend_objects_store_del(orig_obj); + } + } + if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { + init_func_run_time_cache(&fbc->op_array); + } + } + + if (IS_CV != IS_CONST) { + + + } + + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; + if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { + zend_objects_store_del(obj); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } + } + /* call static method */ + obj = (zend_object*)called_scope; + call_info = ZEND_CALL_NESTED_FUNCTION; + } else if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_TMP_VAR|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { + GC_ADDREF(obj); /* For $this pointer */ + } + /* CV may be changed indirectly (e.g. when it's a reference) */ + call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; + } + + call = zend_vm_stack_push_call_frame(call_info, + fbc, opline->extended_value, obj); + call->prev_execute_data = EX(call); + EX(call) = call; + + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + double d1, d2; + + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + op2 = EX_VAR(opline->op2.var); + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { +case_true: + ZEND_VM_SMART_BRANCH_TRUE(); + } else { +case_false: + ZEND_VM_SMART_BRANCH_FALSE(); + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = (double)Z_LVAL_P(op1); + d2 = Z_DVAL_P(op2); + goto case_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { + d1 = Z_DVAL_P(op1); + d2 = Z_DVAL_P(op2); +case_double: + if (d1 == d2) { + goto case_true; + } else { + goto case_false; + } + } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { + d1 = Z_DVAL_P(op1); + d2 = (double)Z_LVAL_P(op2); + goto case_double; + } + } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { + bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); + + + if (result) { + goto case_true; + } else { + goto case_false; + } + } } + ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -71934,8 +75943,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ zval *offset; SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = RT_CONSTANT(opline, opline->op2); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = EX_VAR(opline->op2.var); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { HashTable *ht; @@ -71947,17 +75956,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ isset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_CONST != IS_CONST) { + if (IS_CV != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index_prop; } } - value = zend_hash_find_ex(ht, str, IS_CONST == IS_CONST); + value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { hval = Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); - } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { offset = Z_REFVAL_P(offset); goto isset_again; } else { @@ -71973,7 +75982,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ result = value != NULL && Z_TYPE_P(value) > IS_NULL && (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); - if (IS_TMP_VAR & (IS_CONST|IS_CV)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_CONST|IS_CV)) { /* avoid exception check */ @@ -71983,14 +75992,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ result = (value == NULL || !i_zend_is_true(value)); } goto isset_dim_obj_exit; - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto isset_dim_obj_array; } } - if (IS_CONST == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } if (!(opline->extended_value & ZEND_ISEMPTY)) { @@ -72006,7 +76015,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -72015,12 +76024,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP zend_string *name, *tmp_name; SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = RT_CONSTANT(opline, opline->op2); + container = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || + ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { result = (opline->extended_value & ZEND_ISEMPTY); @@ -72032,7 +76041,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP } } - if (IS_CONST == IS_CONST) { + if (IS_CV == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -72044,9 +76053,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP result = (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - if (IS_CONST != IS_CONST) { + if (IS_CV != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -72057,7 +76066,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -72067,15 +76076,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_S SAVE_OPLINE(); - key = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - subject = RT_CONSTANT(opline, opline->op2); + key = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + subject = EX_VAR(opline->op2.var); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { array_key_exists_array: ht = Z_ARRVAL_P(subject); result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); } else { - if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { subject = Z_REFVAL_P(subject); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { goto array_key_exists_array; @@ -72090,771 +76099,1180 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_S ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETURN_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *expr; - bool result; + zval *retval_ptr; + zval *return_value; - SAVE_OPLINE(); - expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); -try_instanceof: - if (Z_TYPE_P(expr) == IS_OBJECT) { - zend_class_entry *ce; + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); - if (IS_CONST == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); - if (UNEXPECTED(ce == NULL)) { - ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); - if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); - } - } - } else if (IS_CONST == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op2.num); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); + + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); } - } else { - ce = Z_CE_P(EX_VAR(opline->op2.var)); } - result = ce && instanceof_function(Z_OBJCE_P(expr), ce); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { - expr = Z_REFVAL_P(expr); - goto try_instanceof; } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_TMP_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + SAVE_OPLINE(); + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } } - result = 0; } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + + + + + + + ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETURN_BY_REF_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *retval_ptr; + zval *return_value; - zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); SAVE_OPLINE(); - if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) { - ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - /* Destroy the previously yielded value */ - zval_ptr_dtor(&generator->value); + return_value = EX(return_value); - /* Destroy the previously yielded key */ - zval_ptr_dtor(&generator->key); - /* Set the new yielded value */ - if (IS_TMP_VAR != IS_UNUSED) { - if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) { - /* Constants and temporary variables aren't yieldable by reference, - * but we still allow them with a notice. */ - if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) { - zval *value; + do { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) || + (IS_TMP_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_VALUE)) { + /* Not supposed to happen, but we'll allow it */ + zend_error(E_NOTICE, "Only variable references should be returned by reference"); - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + retval_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (!return_value) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } else { + if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_ISREF_P(retval_ptr))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + break; + } - value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - ZVAL_COPY_VALUE(&generator->value, value); + ZVAL_NEW_REF(return_value, retval_ptr); if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) { - Z_ADDREF(generator->value); - } + Z_TRY_ADDREF_P(retval_ptr); } - } else { - zval *value_ptr = zend_get_bad_ptr(); - - /* If a function call result is yielded and the function did - * not return by reference we throw a notice. */ - do { - if (IS_TMP_VAR == IS_VAR) { - ZEND_ASSERT(value_ptr != &EG(uninitialized_zval)); - if (opline->extended_value == ZEND_RETURNS_FUNCTION - && !Z_ISREF_P(value_ptr)) { - zend_error(E_NOTICE, "Only variable references should be yielded by reference"); - ZVAL_COPY(&generator->value, value_ptr); - break; - } - } - if (Z_ISREF_P(value_ptr)) { - Z_ADDREF_P(value_ptr); - } else { - ZVAL_MAKE_REF_EX(value_ptr, 2); - } - ZVAL_REF(&generator->value, Z_REF_P(value_ptr)); - } while (0); - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); } - } else { - zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - /* Consts, temporary variables and references need copying */ - if (IS_TMP_VAR == IS_CONST) { - ZVAL_COPY_VALUE(&generator->value, value); - if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) { - Z_ADDREF(generator->value); - } - } else if (IS_TMP_VAR == IS_TMP_VAR) { - ZVAL_COPY_VALUE(&generator->value, value); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { - ZVAL_COPY(&generator->value, Z_REFVAL_P(value)); + break; + } + retval_ptr = zend_get_bad_ptr(); - } else { - ZVAL_COPY_VALUE(&generator->value, value); - if (IS_TMP_VAR == IS_CV) { - if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); + if (IS_TMP_VAR == IS_VAR) { + ZEND_ASSERT(retval_ptr != &EG(uninitialized_zval)); + if (opline->extended_value == ZEND_RETURNS_FUNCTION && !Z_ISREF_P(retval_ptr)) { + zend_error(E_NOTICE, "Only variable references should be returned by reference"); + if (return_value) { + ZVAL_NEW_REF(return_value, retval_ptr); + } else { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); } + break; } } - } else { - /* If no value was specified yield null */ - ZVAL_NULL(&generator->value); - } - /* Set the new yielded key */ - if (IS_CONST != IS_UNUSED) { - zval *key = RT_CONSTANT(opline, opline->op2); - if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { - key = Z_REFVAL_P(key); + if (return_value) { + if (Z_ISREF_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } else { + ZVAL_MAKE_REF_EX(retval_ptr, 2); + } + ZVAL_REF(return_value, Z_REF_P(retval_ptr)); } - ZVAL_COPY(&generator->key, key); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } while (0); - if (Z_TYPE(generator->key) == IS_LONG - && Z_LVAL(generator->key) > generator->largest_used_integer_key - ) { - generator->largest_used_integer_key = Z_LVAL(generator->key); - } - } else { - /* If no key was specified we use auto-increment keys */ - generator->largest_used_integer_key++; - ZVAL_LONG(&generator->key, generator->largest_used_integer_key); - } - if (RETURN_VALUE_USED(opline)) { - /* If the return value of yield is used set the send - * target and initialize it to NULL */ - generator->send_target = EX_VAR(opline->result.var); - ZVAL_NULL(generator->send_target); - } else { - generator->send_target = NULL; - } - /* The GOTO VM uses a local opline variable. We need to set the opline - * variable in execute_data so we don't resume at an old position. */ - SAVE_OPLINE(); - ZEND_VM_RETURN(); + ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IN_ARRAY_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GENERATOR_RETURN_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1; - HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); - zval *result; + zval *retval; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - ZEND_VM_SMART_BRANCH(result, 0); - } + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); - if (opline->extended_value) { - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - ZEND_VM_SMART_BRANCH(result, 0); - } - SAVE_OPLINE(); - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { - op1 = Z_REFVAL_P(op1); - if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - result = zend_hash_find(ht, Z_STR_P(op1)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - result = zend_hash_index_find(ht, Z_LVAL_P(op1)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); - } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - } else if (Z_TYPE_P(op1) <= IS_FALSE) { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - SAVE_OPLINE(); - ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - HANDLE_EXCEPTION(); - } - } - result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); - ZEND_VM_SMART_BRANCH(result, 0); - } else { - zend_string *key; - zval key_tmp; + SAVE_OPLINE(); + retval = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { - op1 = Z_REFVAL_P(op1); - if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - result = zend_hash_find(ht, Z_STR_P(op1)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 0); + /* Copy return value into generator->retval */ + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(&generator->retval, retval); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->retval))) { + Z_ADDREF(generator->retval); } } + } else if (IS_TMP_VAR == IS_CV) { + ZVAL_COPY_DEREF(&generator->retval, retval); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval))) { + zend_refcounted *ref = Z_COUNTED_P(retval); - SAVE_OPLINE(); - ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) { - ZVAL_STR(&key_tmp, key); - if (zend_compare(op1, &key_tmp) == 0) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(1, 1); + retval = Z_REFVAL_P(retval); + ZVAL_COPY_VALUE(&generator->retval, retval); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval)) { + Z_ADDREF_P(retval); } - } ZEND_HASH_FOREACH_END(); + } else { + ZVAL_COPY_VALUE(&generator->retval, retval); + } } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(0, 1); + + + EG(current_execute_data) = EX(prev_execute_data); + + /* Close the generator to free up resources */ + zend_generator_close(generator, 1); + + /* Pass execution back to handling code */ + ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; + zval *arg, *param; SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - div_function(EX_VAR(opline->result.var), op1, op2); + + arg = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; + zval *expr; + zval *result = EX_VAR(opline->result.var); SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - pow_function(EX_VAR(opline->result.var), op1, op2); + expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + switch (opline->extended_value) { + case IS_LONG: + ZVAL_LONG(result, zval_get_long(expr)); + break; + case IS_DOUBLE: + ZVAL_DOUBLE(result, zval_get_double(expr)); + break; + case IS_STRING: + ZVAL_STR(result, zval_get_string(expr)); + break; + default: + ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead"); + if (IS_TMP_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + /* If value is already of correct type, return it directly */ + if (Z_TYPE_P(expr) == opline->extended_value) { + ZVAL_COPY_VALUE(result, expr); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_TMP_VAR != IS_TMP_VAR) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (opline->extended_value == IS_ARRAY) { + zend_cast_zval_to_array(result, expr, IS_TMP_VAR); + } else { + ZEND_ASSERT(opline->extended_value == IS_OBJECT); + zend_cast_zval_to_object(result, expr, IS_TMP_VAR); + } + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_R_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; + zval *array_ptr, *result; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + SAVE_OPLINE(); - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); + array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { + result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, array_ptr); + if (IS_TMP_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(array_ptr); + } + Z_FE_POS_P(result) = 0; - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); + + ZEND_VM_NEXT_OPCODE(); + } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { + zend_object *zobj = Z_OBJ_P(array_ptr); + if (!zobj->ce->get_iterator) { + if (UNEXPECTED(zend_object_is_lazy(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (UNEXPECTED(EG(exception))) { + UNDEF_RESULT(); + + + HANDLE_EXCEPTION(); + } } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); + HashTable *properties = zobj->properties; + if (properties) { + if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(properties); + } + properties = zobj->properties = zend_array_dup(properties); + } } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); + properties = zobj->handlers->get_properties(zobj); } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); - if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { - zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); + result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, array_ptr); + if (IS_TMP_VAR != IS_TMP_VAR) { + Z_ADDREF_P(array_ptr); } - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); + + if (zend_hash_num_elements(properties) == 0) { + Z_FE_ITER_P(result) = (uint32_t) -1; + + + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } + + Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); + bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } else if (is_empty) { + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else { + ZEND_VM_NEXT_OPCODE(); } } - ZEND_VM_NEXT_OPCODE(); } else { - SAVE_OPLINE(); - - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - op1 = ZVAL_UNDEFINED_OP1(); - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - op2 = ZVAL_UNDEFINED_OP2(); - } - concat_function(EX_VAR(opline->result.var), op1, op2); + zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_RW_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - bool result; + zval *array_ptr, *array_ref; SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_identical_function(op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; + if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { + array_ref = array_ptr = zend_get_bad_ptr(); + if (Z_ISREF_P(array_ref)) { + array_ptr = Z_REFVAL_P(array_ref); + } + } else { + array_ref = array_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + } - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_identical_function(op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} + if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { + if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { + if (array_ptr == array_ref) { + ZVAL_NEW_REF(array_ref, array_ref); + array_ptr = Z_REFVAL_P(array_ref); + } + Z_ADDREF_P(array_ref); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); + } else { + array_ref = EX_VAR(opline->result.var); + ZVAL_NEW_REF(array_ref, array_ptr); + array_ptr = Z_REFVAL_P(array_ref); + } + if (IS_TMP_VAR == IS_CONST) { + ZVAL_ARR(array_ptr, zend_array_dup(Z_ARRVAL_P(array_ptr))); + } else { + SEPARATE_ARRAY(array_ptr); + } + Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(Z_ARRVAL_P(array_ptr), 0); -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_not_identical_function(op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} + ZEND_VM_NEXT_OPCODE(); + } else if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { + if (!Z_OBJCE_P(array_ptr)->get_iterator) { + zend_object *zobj = Z_OBJ_P(array_ptr); + HashTable *properties; + if (UNEXPECTED(zend_object_is_lazy(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (UNEXPECTED(EG(exception))) { + UNDEF_RESULT(); -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); + HANDLE_EXCEPTION(); + } } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; + if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) { + if (array_ptr == array_ref) { + ZVAL_NEW_REF(array_ref, array_ref); + array_ptr = Z_REFVAL_P(array_ref); + } + Z_ADDREF_P(array_ref); + ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref); } else { - goto is_equal_false; + array_ptr = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(array_ptr, array_ref); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); + if (Z_OBJ_P(array_ptr)->properties + && UNEXPECTED(GC_REFCOUNT(Z_OBJ_P(array_ptr)->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(Z_OBJ_P(array_ptr)->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(Z_OBJ_P(array_ptr)->properties); + } + Z_OBJ_P(array_ptr)->properties = zend_array_dup(Z_OBJ_P(array_ptr)->properties); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + + properties = Z_OBJPROP_P(array_ptr); + if (zend_hash_num_elements(properties) == 0) { + Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t) -1; + + + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } - if (result) { - goto is_equal_true; + + Z_FE_ITER_P(EX_VAR(opline->result.var)) = zend_hash_iterator_add(properties, 0); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + bool is_empty = zend_fe_reset_iterator(array_ptr, 1 OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } else if (is_empty) { + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); } else { - goto is_equal_false; + ZEND_VM_NEXT_OPCODE(); } } + } else { + zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_END_SILENCE_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; + if (E_HAS_ONLY_FATAL_ERRORS(EG(error_reporting)) + && !E_HAS_ONLY_FATAL_ERRORS(Z_LVAL_P(EX_VAR(opline->op1.var)))) { + EG(error_reporting) = Z_LVAL_P(EX_VAR(opline->op1.var)); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMP_SET_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zend_reference *ref = NULL; + bool ret; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && Z_ISREF_P(value)) { + if (IS_TMP_VAR == IS_VAR) { + ref = Z_REF_P(value); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; + value = Z_REFVAL_P(value); + } + + ret = i_zend_is_true(value); + + if (UNEXPECTED(EG(exception))) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + + if (ret) { + zval *result = EX_VAR(opline->result.var); + + ZVAL_COPY_VALUE(result, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_TMP_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } else if (IS_TMP_VAR == IS_VAR && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COALESCE_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zend_reference *ref = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { + if (IS_TMP_VAR & IS_VAR) { + ref = Z_REF_P(value); + } + value = Z_REFVAL_P(value); + } + + if (Z_TYPE_P(value) > IS_NULL) { + zval *result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_TMP_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } else if ((IS_TMP_VAR & IS_VAR) && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); } } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + if ((IS_TMP_VAR & IS_VAR) && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMP_NULL_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *val, *result; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -is_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); - } else { -is_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); + val = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_P(val) > IS_NULL) { + do { + if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) { + val = Z_REFVAL_P(val); + if (Z_TYPE_P(val) <= IS_NULL) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + break; + } } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_equal_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_equal_double: - if (d1 == d2) { - goto is_equal_true; - } else { - goto is_equal_false; + ZEND_VM_NEXT_OPCODE(); + } while (0); + } + + result = EX_VAR(opline->result.var); + uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK; + if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { + ZVAL_NULL(result); + if (IS_TMP_VAR == IS_CV + && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF) + && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0 + ) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { + ZVAL_FALSE(result); + } else { + ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); + ZVAL_TRUE(result); + } + + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_QM_ASSIGN_SPEC_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *result = EX_VAR(opline->result.var); + + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + ZVAL_NULL(result); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (IS_TMP_VAR == IS_CV) { + ZVAL_COPY_DEREF(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); } - if (result) { - goto is_equal_true; - } else { - goto is_equal_false; + } else { + ZVAL_COPY_VALUE(result, value); + } + } else { + ZVAL_COPY_VALUE(result, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) { + Z_ADDREF_P(result); } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; - double d1, d2; + bool result; + SAVE_OPLINE(); op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_NONE(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_NONE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 + USE_OPLINE +#endif + + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; + ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + if (IS_CONST == IS_UNUSED) { + ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); - } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; - } + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 + USE_OPLINE +#endif + + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + /* Behave like FETCH_OBJ_W */ + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } + ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_ADD_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zend_string **rope; + zval *var; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPZ(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; + /* op1 and result are the same */ + rope = (zend_string**)EX_VAR(opline->op1.var); + if (IS_CONST == IS_CONST) { + var = RT_CONSTANT(opline, opline->op2); + rope[opline->extended_value] = Z_STR_P(var); + if (UNEXPECTED(Z_REFCOUNTED_P(var))) { + Z_ADDREF_P(var); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; + } else { + var = RT_CONSTANT(opline, opline->op2); + if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { + if (IS_CONST == IS_CV) { + rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); } else { - goto is_not_equal_false; + rope[opline->extended_value] = Z_STR_P(var); } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; + } else { + SAVE_OPLINE(); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); + } + rope[opline->extended_value] = zval_get_string_func(var); + + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_END_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zend_string **rope; + zval *var, *ret; + uint32_t i; + + rope = (zend_string**)EX_VAR(opline->op1.var); + if (IS_CONST == IS_CONST) { + var = RT_CONSTANT(opline, opline->op2); + rope[opline->extended_value] = Z_STR_P(var); + if (UNEXPECTED(Z_REFCOUNTED_P(var))) { + Z_ADDREF_P(var); + } + } else { + var = RT_CONSTANT(opline, opline->op2); + if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { + if (IS_CONST == IS_CV) { + rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); + } else { + rope[opline->extended_value] = Z_STR_P(var); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); + } else { + SAVE_OPLINE(); + if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP2(); } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + rope[opline->extended_value] = zval_get_string_func(var); + + + if (UNEXPECTED(EG(exception))) { + for (i = 0; i <= opline->extended_value; i++) { + zend_string_release_ex(rope[i], 0); + } + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); } } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + + size_t len = 0; + uint32_t flags = ZSTR_COPYABLE_CONCAT_PROPERTIES; + for (i = 0; i <= opline->extended_value; i++) { + flags &= ZSTR_GET_COPYABLE_CONCAT_PROPERTIES(rope[i]); + len += ZSTR_LEN(rope[i]); + } + ret = EX_VAR(opline->result.var); + ZVAL_STR(ret, zend_string_alloc(len, 0)); + GC_ADD_FLAGS(Z_STR_P(ret), flags); + + char *target = Z_STRVAL_P(ret); + for (i = 0; i <= opline->extended_value; i++) { + memcpy(target, ZSTR_VAL(rope[i]), ZSTR_LEN(rope[i])); + target += ZSTR_LEN(rope[i]); + zend_string_release_ex(rope[i], 0); + } + *target = '\0'; + + ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAL_EX_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; - double d1, d2; + zval *value, *arg; + uint32_t arg_num; - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_TMP_VAR == IS_CONST && IS_TMP_VAR == IS_CONST) { - /* pass */ - } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) != Z_LVAL_P(op2))) { -is_not_equal_true: - ZEND_VM_SMART_BRANCH_TRUE_JMPNZ(); - } else { -is_not_equal_false: - ZEND_VM_SMART_BRANCH_FALSE_JMPNZ(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto is_not_equal_double; + if (IS_CONST == IS_CONST) { + SAVE_OPLINE(); + zend_string *arg_name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + arg = zend_handle_named_arg(&EX(call), arg_name, &arg_num, CACHE_ADDR(opline->result.num)); + if (UNEXPECTED(!arg)) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -is_not_equal_double: - if (d1 != d2) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + } else { + arg = ZEND_CALL_VAR(EX(call), opline->result.var); + arg_num = opline->op2.num; + } + + if (EXPECTED(arg_num <= MAX_ARG_FLAG_NUM)) { + if (QUICK_ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { + goto send_val_by_ref; + } + } else if (ARG_MUST_BE_SENT_BY_REF(EX(call)->func, arg_num)) { +send_val_by_ref:; + ZEND_VM_DISPATCH_TO_HELPER(zend_cannot_pass_by_ref_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX arg_num, arg)); + } + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(arg, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(arg))) { + Z_ADDREF_P(arg); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr_ptr, new_expr; + + SAVE_OPLINE(); + if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && + UNEXPECTED(opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) { + expr_ptr = zend_get_bad_ptr(); + if (Z_ISREF_P(expr_ptr)) { + Z_ADDREF_P(expr_ptr); + } else { + ZVAL_MAKE_REF_EX(expr_ptr, 2); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } else { + expr_ptr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_TMP_VAR) { + /* pass */ + } else if (IS_TMP_VAR == IS_CONST) { + Z_TRY_ADDREF_P(expr_ptr); + } else if (IS_TMP_VAR == IS_CV) { + ZVAL_DEREF(expr_ptr); + Z_TRY_ADDREF_P(expr_ptr); + } else /* if (IS_TMP_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(expr_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(expr_ptr); + + expr_ptr = Z_REFVAL_P(expr_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + ZVAL_COPY_VALUE(&new_expr, expr_ptr); + expr_ptr = &new_expr; + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(expr_ptr)) { + Z_ADDREF_P(expr_ptr); + } } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto is_not_equal_double; } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op1); + } + + if (IS_CONST != IS_UNUSED) { + zval *offset = RT_CONSTANT(opline, opline->op2); + zend_string *str; + zend_ulong hval; + +add_again: + if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { + str = Z_STR_P(offset); + if (IS_CONST != IS_CONST) { + if (ZEND_HANDLE_NUMERIC(str, hval)) { + goto num_index; + } } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zval_ptr_dtor_str(op2); +str_index: + zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr); + } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { + hval = Z_LVAL_P(offset); +num_index: + zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); + } else if ((IS_CONST & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + offset = Z_REFVAL_P(offset); + goto add_again; + } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { + zval tmp; + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_COPY(&tmp, expr_ptr); } - if (!result) { - goto is_not_equal_true; - } else { - goto is_not_equal_false; + zend_error(E_DEPRECATED, "Using null as an array offset is deprecated, use an empty string instead"); + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + /* A userland error handler can do funky things to the expression, so reset it */ + zval_ptr_dtor(expr_ptr); + ZVAL_COPY_VALUE(expr_ptr, &tmp); } + if (UNEXPECTED(EG(exception))) { + zval_ptr_dtor_nogc(expr_ptr); + HANDLE_EXCEPTION(); + } + str = ZSTR_EMPTY_ALLOC(); + goto str_index; + } else if (Z_TYPE_P(offset) == IS_DOUBLE) { + hval = zend_dval_to_lval_safe(Z_DVAL_P(offset)); + goto num_index; + } else if (Z_TYPE_P(offset) == IS_FALSE) { + hval = 0; + goto num_index; + } else if (Z_TYPE_P(offset) == IS_TRUE) { + hval = 1; + goto num_index; + } else if (Z_TYPE_P(offset) == IS_RESOURCE) { + zend_use_resource_as_offset(offset); + hval = Z_RES_HANDLE_P(offset); + goto num_index; + } else if (IS_CONST == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + ZVAL_UNDEFINED_OP2(); + str = ZSTR_EMPTY_ALLOC(); + goto str_index; + } else { + zend_illegal_array_offset_access(offset); + zval_ptr_dtor_nogc(expr_ptr); + } + + + } else { + if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { + zend_cannot_add_element(); + zval_ptr_dtor_nogc(expr_ptr); } } - ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + uint32_t size; USE_OPLINE - zval *op1, *op2; SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - compare_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + array = EX_VAR(opline->result.var); + if (IS_TMP_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + ZVAL_ARR(array, zend_new_array(size)); + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init_mixed(Z_ARRVAL_P(array)); + } + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + ZVAL_ARR(array, zend_new_array(0)); + ZEND_VM_NEXT_OPCODE(); + } +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + + zend_generator *generator = zend_get_running_generator(EXECUTE_DATA_C); + + SAVE_OPLINE(); + if (UNEXPECTED(generator->flags & ZEND_GENERATOR_FORCED_CLOSE)) { + ZEND_VM_TAIL_CALL(zend_yield_in_closed_generator_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + + /* Destroy the previously yielded value */ + zval_ptr_dtor(&generator->value); + + /* Destroy the previously yielded key */ + zval_ptr_dtor(&generator->key); + + /* Set the new yielded value */ + if (IS_TMP_VAR != IS_UNUSED) { + if (UNEXPECTED(EX(func)->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE)) { + /* Constants and temporary variables aren't yieldable by reference, + * but we still allow them with a notice. */ + if (IS_TMP_VAR & (IS_CONST|IS_TMP_VAR)) { + zval *value; + + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + + value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + ZVAL_COPY_VALUE(&generator->value, value); + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) { + Z_ADDREF(generator->value); + } + } + } else { + zval *value_ptr = zend_get_bad_ptr(); + + /* If a function call result is yielded and the function did + * not return by reference we throw a notice. */ + do { + if (IS_TMP_VAR == IS_VAR) { + ZEND_ASSERT(value_ptr != &EG(uninitialized_zval)); + if (opline->extended_value == ZEND_RETURNS_FUNCTION + && !Z_ISREF_P(value_ptr)) { + zend_error(E_NOTICE, "Only variable references should be yielded by reference"); + ZVAL_COPY(&generator->value, value_ptr); + break; + } + } + if (Z_ISREF_P(value_ptr)) { + Z_ADDREF_P(value_ptr); + } else { + ZVAL_MAKE_REF_EX(value_ptr, 2); + } + ZVAL_REF(&generator->value, Z_REF_P(value_ptr)); + } while (0); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + } + } else { + zval *value = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + + /* Consts, temporary variables and references need copying */ + if (IS_TMP_VAR == IS_CONST) { + ZVAL_COPY_VALUE(&generator->value, value); + if (UNEXPECTED(Z_OPT_REFCOUNTED(generator->value))) { + Z_ADDREF(generator->value); + } + } else if (IS_TMP_VAR == IS_TMP_VAR) { + ZVAL_COPY_VALUE(&generator->value, value); + } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { + ZVAL_COPY(&generator->value, Z_REFVAL_P(value)); + + + } else { + ZVAL_COPY_VALUE(&generator->value, value); + if (IS_TMP_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(value)) Z_ADDREF_P(value); + } + } + } + } else { + /* If no value was specified yield null */ + ZVAL_NULL(&generator->value); + } + + /* Set the new yielded key */ + if (IS_CONST != IS_UNUSED) { + zval *key = RT_CONSTANT(opline, opline->op2); + if ((IS_CONST & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + key = Z_REFVAL_P(key); + } + ZVAL_COPY(&generator->key, key); + + + if (Z_TYPE(generator->key) == IS_LONG + && Z_LVAL(generator->key) > generator->largest_used_integer_key + ) { + generator->largest_used_integer_key = Z_LVAL(generator->key); + } + } else { + /* If no key was specified we use auto-increment keys */ + generator->largest_used_integer_key++; + ZVAL_LONG(&generator->key, generator->largest_used_integer_key); + } + + if (RETURN_VALUE_USED(opline)) { + /* If the return value of yield is used set the send + * target and initialize it to NULL */ + generator->send_target = EX_VAR(opline->result.var); + ZVAL_NULL(generator->send_target); + } else { + generator->send_target = NULL; + } + + /* The GOTO VM uses a local opline variable. We need to set the opline + * variable in execute_data so we don't resume at an old position. */ + SAVE_OPLINE(); + + ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_XOR_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IN_ARRAY_SPEC_TMP_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *op1, *op2; + zval *op1; + HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); + zval *result; - SAVE_OPLINE(); op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - boolean_xor_function(EX_VAR(opline->result.var), op1, op2); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_TMP_VAR == IS_CONST); + if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + ZEND_VM_SMART_BRANCH(result, 0); + } + + if (opline->extended_value) { + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + ZEND_VM_SMART_BRANCH(result, 0); + } + SAVE_OPLINE(); + if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find(ht, Z_STR_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } + } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + } else if (Z_TYPE_P(op1) <= IS_FALSE) { + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); + ZEND_VM_SMART_BRANCH(result, 0); + } else { + zend_string *key; + zval key_tmp; + + if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find(ht, Z_STR_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } + } + + SAVE_OPLINE(); + ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) { + ZVAL_STR(&key_tmp, key); + if (zend_compare(op1, &key_tmp) == 0) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(1, 1); + } + } ZEND_HASH_FOREACH_END(); + } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + ZEND_VM_SMART_BRANCH(0, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -72866,20 +77284,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_TMP_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -72892,142 +77304,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - zend_string *op1_str, *op2_str, *str; - - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); - - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } - ZEND_VM_NEXT_OPCODE(); - } - - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CONST) { - op1_str = Z_STR_P(op1); - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - op1_str = zend_string_copy(Z_STR_P(op1)); - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - op1_str = zval_get_string_func(op1); - } - if (IS_TMP_VAR == IS_CONST) { - op2_str = Z_STR_P(op2); - } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - op2_str = zend_string_copy(Z_STR_P(op2)); - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - } - op2_str = zval_get_string_func(op2); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - do { - if (IS_TMP_VAR != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { - GC_ADDREF(op2_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - zend_string_release_ex(op1_str, 0); - break; - } - } - if (IS_TMP_VAR != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { - GC_ADDREF(op1_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - zend_string_release_ex(op2_str, 0); - break; - } - } - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - - ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR != IS_CONST) { - zend_string_release_ex(op1_str, 0); - } - if (IS_TMP_VAR != IS_CONST) { - zend_string_release_ex(op2_str, 0); - } - } while (0); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_ADD_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_string **rope; @@ -73035,23 +77316,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_ADD_SPEC_TMP_ /* op1 and result are the same */ rope = (zend_string**)EX_VAR(opline->op1.var); - if (IS_TMP_VAR == IS_CONST) { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); rope[opline->extended_value] = Z_STR_P(var); if (UNEXPECTED(Z_REFCOUNTED_P(var))) { Z_ADDREF_P(var); } } else { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); } else { rope[opline->extended_value] = Z_STR_P(var); } } else { SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } rope[opline->extended_value] = zval_get_string_func(var); @@ -73062,7 +77343,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_ADD_SPEC_TMP_ ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_END_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_END_SPEC_TMP_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_string **rope; @@ -73070,23 +77351,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_END_SPEC_TMP_ uint32_t i; rope = (zend_string**)EX_VAR(opline->op1.var); - if (IS_TMP_VAR == IS_CONST) { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); rope[opline->extended_value] = Z_STR_P(var); if (UNEXPECTED(Z_REFCOUNTED_P(var))) { Z_ADDREF_P(var); } } else { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { rope[opline->extended_value] = zend_string_copy(Z_STR_P(var)); } else { rope[opline->extended_value] = Z_STR_P(var); } } else { SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } rope[opline->extended_value] = zval_get_string_func(var); @@ -73122,213 +77403,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_END_SPEC_TMP_ ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - if (IS_TMP_VAR != IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - } - - if (IS_TMP_VAR != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_TMP_VAR == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_TMP_VAR & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - HANDLE_EXCEPTION(); - } - } - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - } - zend_invalid_method_call(object, function_name); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_TMP_VAR == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_TMP_VAR == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - } - } - - if (IS_TMP_VAR != IS_CONST) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_TMP_VAR == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -case_true: - ZEND_VM_SMART_BRANCH_TRUE(); - } else { -case_false: - ZEND_VM_SMART_BRANCH_FALSE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -case_double: - if (d1 == d2) { - goto case_true; - } else { - goto case_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - if (result) { - goto case_true; - } else { - goto case_false; - } - } - } - ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *expr_ptr, new_expr; @@ -73368,15 +77443,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ } } - if (IS_TMP_VAR != IS_UNUSED) { - zval *offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_string *str; zend_ulong hval; add_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index; } @@ -73387,7 +77462,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ hval = Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto add_again; } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { @@ -73420,7 +77495,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -73429,200 +77504,38 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ zval_ptr_dtor_nogc(expr_ptr); } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } else { - if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { - zend_cannot_add_element(); - zval_ptr_dtor_nogc(expr_ptr); - } - } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - zval *array; - uint32_t size; - USE_OPLINE - - SAVE_OPLINE(); - array = EX_VAR(opline->result.var); - if (IS_TMP_VAR != IS_UNUSED) { - size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; - ZVAL_ARR(array, zend_new_array(size)); - /* Explicitly initialize array as not-packed if flag is set */ - if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { - zend_hash_real_init_mixed(Z_ARRVAL_P(array)); - } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } else { - ZVAL_ARR(array, zend_new_array(0)); - ZEND_VM_NEXT_OPCODE(); - } -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container; - bool result; - zend_ulong hval; - zval *offset; - - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - HashTable *ht; - zval *value; - zend_string *str; - -isset_dim_obj_array: - ht = Z_ARRVAL_P(container); -isset_again: - if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_prop; - } - } - value = zend_hash_find_ex(ht, str, IS_TMP_VAR == IS_CONST); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_prop: - value = zend_hash_index_find(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { - offset = Z_REFVAL_P(offset); - goto isset_again; - } else { - value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); - if (UNEXPECTED(EG(exception))) { - result = 0; - goto isset_dim_obj_exit; - } - } - - if (!(opline->extended_value & ZEND_ISEMPTY)) { - /* > IS_NULL means not IS_UNDEF and not IS_NULL */ - result = value != NULL && Z_TYPE_P(value) > IS_NULL && - (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); - - if (IS_TMP_VAR & (IS_CONST|IS_CV)) { - /* avoid exception check */ - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 0); - } - } else { - result = (value == NULL || !i_zend_is_true(value)); - } - goto isset_dim_obj_exit; - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto isset_dim_obj_array; - } - } - - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { - offset++; - } - if (!(opline->extended_value & ZEND_ISEMPTY)) { - result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); - } else { - result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); - } - -isset_dim_obj_exit: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container; - int result; - zval *offset; - zend_string *name, *tmp_name; - - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; - } - } else { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; - } - } - - if (IS_TMP_VAR == IS_CONST) { - name = Z_STR_P(offset); - } else { - name = zval_try_get_tmp_string(offset, &tmp_name); - if (UNEXPECTED(!name)) { - result = 0; - goto isset_object_finish; - } - } - - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); + } else { + if (!zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr)) { + zend_cannot_add_element(); + zval_ptr_dtor_nogc(expr_ptr); + } } - -isset_object_finish: - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { + zval *array; + uint32_t size; USE_OPLINE - zval *key, *subject; - HashTable *ht; - bool result; - SAVE_OPLINE(); - - key = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - subject = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { -array_key_exists_array: - ht = Z_ARRVAL_P(subject); - result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); - } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { - subject = Z_REFVAL_P(subject); - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { - goto array_key_exists_array; - } + array = EX_VAR(opline->result.var); + if (IS_TMP_VAR != IS_UNUSED) { + size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT; + ZVAL_ARR(array, zend_new_array(size)); + /* Explicitly initialize array as not-packed if flag is set */ + if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { + zend_hash_real_init_mixed(Z_ARRVAL_P(array)); } - zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); - result = 0; + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + ZVAL_ARR(array, zend_new_array(0)); + ZEND_VM_NEXT_OPCODE(); } - - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -73709,9 +77622,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_TMP } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -73744,86 +77657,64 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_TMP ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_TMP_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE - zval *expr; + zval *op1, *op2; bool result; SAVE_OPLINE(); - expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - -try_instanceof: - if (Z_TYPE_P(expr) == IS_OBJECT) { - zend_class_entry *ce; - - if (IS_VAR == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); - if (UNEXPECTED(ce == NULL)) { - ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); - if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); - } - } - } else if (IS_VAR == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op2.num); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op2.var)); - } - result = ce && instanceof_function(Z_OBJCE_P(expr), ce); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { - expr = Z_REFVAL_P(expr); - goto try_instanceof; - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - result = 0; - } + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_SMART_BRANCH(result, 1); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX zend_fetch_var_address_helper_SPEC_TMP_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_EX int type); -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_R_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_R)); -} + USE_OPLINE + zval *op1, *op2; + bool result; -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_W_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_W)); + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_RW_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_RW)); -} + USE_OPLINE + zval *op1, *op2; + bool result; -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - int fetch_type = - (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) ? - BP_VAR_W : BP_VAR_R; - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX fetch_type)); + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_TMP_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_UNSET)); -} + USE_OPLINE + zval *op1, *op2; + bool result; -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_IS_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_TMP_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); + SAVE_OPLINE(); + op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 @@ -73839,12 +77730,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_UNUSED == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_TMP_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -74123,96 +78008,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_TM } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - bool result; - zval *varname; - zend_string *name, *tmp_name; - HashTable *target_symbol_table; - - SAVE_OPLINE(); - varname = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { - name = Z_STR_P(varname); - } else { - name = zval_get_tmp_string(varname, &tmp_name); - } - - target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); - value = zend_hash_find_ex(target_symbol_table, name, IS_TMP_VAR == IS_CONST); - - if (IS_TMP_VAR != IS_CONST) { - zend_tmp_string_release(tmp_name); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - if (!value) { - result = (opline->extended_value & ZEND_ISEMPTY); - } else { - if (Z_TYPE_P(value) == IS_INDIRECT) { - value = Z_INDIRECT_P(value); - } - if (!(opline->extended_value & ZEND_ISEMPTY)) { - if (Z_ISREF_P(value)) { - value = Z_REFVAL_P(value); - } - result = Z_TYPE_P(value) > IS_NULL; - } else { - result = !i_zend_is_true(value); - } - } - - ZEND_VM_SMART_BRANCH(result, true); -} - -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *expr; - bool result; - - SAVE_OPLINE(); - expr = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - -try_instanceof: - if (Z_TYPE_P(expr) == IS_OBJECT) { - zend_class_entry *ce; - - if (IS_UNUSED == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); - if (UNEXPECTED(ce == NULL)) { - ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); - if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); - } - } - } else if (IS_UNUSED == IS_UNUSED) { - ce = zend_fetch_class(NULL, opline->op2.num); - if (UNEXPECTED(ce == NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } - } else { - ce = Z_CE_P(EX_VAR(opline->op2.var)); - } - result = ce && instanceof_function(Z_OBJCE_P(expr), ce); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { - expr = Z_REFVAL_P(expr); - goto try_instanceof; - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(expr) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - result = 0; - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -74335,119 +78130,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_UNU ZEND_VM_RETURN(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COUNT_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1; - zend_long count; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - while (1) { - if (Z_TYPE_P(op1) == IS_ARRAY) { - count = zend_hash_num_elements(Z_ARRVAL_P(op1)); - break; - } else if (Z_TYPE_P(op1) == IS_OBJECT) { - zend_object *zobj = Z_OBJ_P(op1); - - /* first, we check if the handler is defined */ - if (zobj->handlers->count_elements) { - if (SUCCESS == zobj->handlers->count_elements(zobj, &count)) { - break; - } - if (UNEXPECTED(EG(exception))) { - count = 0; - break; - } - } - - /* if not and the object implements Countable we call its count() method */ - if (zend_class_implements_interface(zobj->ce, zend_ce_countable)) { - zval retval; - - zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT)); - zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval); - count = zval_get_long(&retval); - zval_ptr_dtor(&retval); - break; - } - - /* If There's no handler and it doesn't implement Countable then emit a TypeError */ - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { - op1 = Z_REFVAL_P(op1); - continue; - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - count = 0; - zend_type_error("%s(): Argument #1 ($value) must be of type Countable|array, %s given", opline->extended_value ? "sizeof" : "count", zend_zval_value_name(op1)); - break; - } - - ZVAL_LONG(EX_VAR(opline->result.var), count); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zend_array *ht = Z_ARRVAL_P(_get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC)); - ZVAL_LONG(EX_VAR(opline->result.var), zend_hash_num_elements(ht)); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR) && !(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { - SAVE_OPLINE(); - zend_array_destroy(ht); - if (EG(exception)) { - HANDLE_EXCEPTION(); - } - } - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GET_CLASS_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - - if (IS_TMP_VAR == IS_UNUSED) { - SAVE_OPLINE(); - if (UNEXPECTED(!EX(func)->common.scope)) { - zend_throw_error(NULL, "get_class() without arguments must be called from within a class"); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - HANDLE_EXCEPTION(); - } else { - zend_error(E_DEPRECATED, "Calling get_class() without arguments is deprecated"); - ZVAL_STR_COPY(EX_VAR(opline->result.var), EX(func)->common.scope->name); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - ZEND_VM_NEXT_OPCODE(); - } - } else { - zval *op1; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - while (1) { - if (Z_TYPE_P(op1) == IS_OBJECT) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), Z_OBJCE_P(op1)->name); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) != 0 && Z_TYPE_P(op1) == IS_REFERENCE) { - op1 = Z_REFVAL_P(op1); - continue; - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); - } - zend_type_error("get_class(): Argument #1 ($object) must be of type object, %s given", zend_zval_value_name(op1)); - ZVAL_UNDEF(EX_VAR(opline->result.var)); - } - break; - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GET_TYPE_SPEC_TMP_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -74466,114 +78148,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GET_TYPE_SPEC_TMP_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - div_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - pow_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = EX_VAR(opline->op2.var); - - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CV == IS_CONST || IS_CV == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); - - if (UNEXPECTED(len > ZSTR_MAX_LEN - ZSTR_LEN(op2_str))) { - zend_error_noreturn(E_ERROR, "Integer overflow in memory allocation"); - } - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } - ZEND_VM_NEXT_OPCODE(); - } else { - SAVE_OPLINE(); - - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - op1 = ZVAL_UNDEFINED_OP1(); - } - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - op2 = ZVAL_UNDEFINED_OP2(); - } - concat_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -74589,193 +78163,40 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_T ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - compare_function(EX_VAR(opline->result.var), op1, op2); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 - USE_OPLINE -#endif - - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } else { - if (IS_CV == IS_UNUSED) { - ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - if (IS_TMP_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ -#if 0 - USE_OPLINE -#endif - - if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { - /* Behave like FETCH_OBJ_W */ - if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { - ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } - ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } else { - if (IS_TMP_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); - } -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - zend_string *op1_str, *op2_str, *str; - - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = EX_VAR(opline->op2.var); - if ((IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { - zend_string *op1_str = Z_STR_P(op1); - zend_string *op2_str = Z_STR_P(op2); - zend_string *str; - uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); - - if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CV == IS_CONST || IS_CV == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - } else if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { - ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); - } else { - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else if (IS_TMP_VAR != IS_CONST && IS_TMP_VAR != IS_CV && - !ZSTR_IS_INTERNED(op1_str) && GC_REFCOUNT(op1_str) == 1) { - size_t len = ZSTR_LEN(op1_str); - - str = zend_string_extend(op1_str, len + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } else { - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - GC_ADD_FLAGS(str, flags); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op1_str, 0); - } - if (IS_CV & (IS_TMP_VAR|IS_VAR)) { - zend_string_release_ex(op2_str, 0); - } - } - ZEND_VM_NEXT_OPCODE(); - } + USE_OPLINE +#endif - SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CONST) { - op1_str = Z_STR_P(op1); - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - op1_str = zend_string_copy(Z_STR_P(op1)); - } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - op1_str = zval_get_string_func(op1); - } - if (IS_CV == IS_CONST) { - op2_str = Z_STR_P(op2); - } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - op2_str = zend_string_copy(Z_STR_P(op2)); + ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); + if (IS_CV == IS_UNUSED) { + ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - op2_str = zval_get_string_func(op2); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - do { - if (IS_TMP_VAR != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_CV == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { - GC_ADDREF(op2_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op2_str); - zend_string_release_ex(op1_str, 0); - break; - } - } - if (IS_CV != IS_CONST) { - if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { - GC_ADDREF(op1_str); - } - } - ZVAL_STR(EX_VAR(opline->result.var), op1_str); - zend_string_release_ex(op2_str, 0); - break; - } - } - str = zend_string_alloc(ZSTR_LEN(op1_str) + ZSTR_LEN(op2_str), 0); - memcpy(ZSTR_VAL(str), ZSTR_VAL(op1_str), ZSTR_LEN(op1_str)); - memcpy(ZSTR_VAL(str) + ZSTR_LEN(op1_str), ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); - - ZSTR_COPY_CONCAT_PROPERTIES_BOTH(str, op1_str, op2_str); - ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR != IS_CONST) { - zend_string_release_ex(op1_str, 0); - } - if (IS_CV != IS_CONST) { - zend_string_release_ex(op2_str, 0); - } - } while (0); - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); +} +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ +#if 0 + USE_OPLINE +#endif - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + if (UNEXPECTED(ZEND_CALL_INFO(EX(call)) & ZEND_CALL_SEND_ARG_BY_REF)) { + /* Behave like FETCH_OBJ_W */ + if ((IS_TMP_VAR & (IS_CONST|IS_TMP_VAR))) { + ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } else { + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } } static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_ADD_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -74875,218 +78296,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_END_SPEC_TMP_ ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *function_name; - zval *object; - zend_function *fbc; - zend_class_entry *called_scope; - zend_object *obj; - zend_execute_data *call; - uint32_t call_info; - - SAVE_OPLINE(); - - object = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - - if (IS_CV != IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - if (IS_CV != IS_CONST && - UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { - do { - if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { - function_name = Z_REFVAL_P(function_name); - if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { - break; - } - } else if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { - ZVAL_UNDEFINED_OP2(); - if (UNEXPECTED(EG(exception) != NULL)) { - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } - zend_throw_error(NULL, "Method name must be a string"); - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } while (0); - } - - if (IS_TMP_VAR == IS_UNUSED) { - obj = Z_OBJ_P(object); - } else { - do { - if (IS_TMP_VAR != IS_CONST && EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(object))) { - zend_reference *ref = Z_REF_P(object); - - object = &ref->val; - if (EXPECTED(Z_TYPE_P(object) == IS_OBJECT)) { - obj = Z_OBJ_P(object); - if (IS_TMP_VAR & IS_VAR) { - if (UNEXPECTED(GC_DELREF(ref) == 0)) { - efree_size(ref, sizeof(zend_reference)); - } else { - Z_ADDREF_P(object); - } - } - break; - } - } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { - object = ZVAL_UNDEFINED_OP1(); - if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_CV != IS_CONST) { - - - } - HANDLE_EXCEPTION(); - } - } - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - zend_invalid_method_call(object, function_name); - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - HANDLE_EXCEPTION(); - } - } while (0); - } - - called_scope = obj->ce; - - if (IS_CV == IS_CONST && - EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { - fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else { - zend_object *orig_obj = obj; - - if (IS_CV == IS_CONST) { - function_name = EX_VAR(opline->op2.var); - } - - /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); - if (UNEXPECTED(fbc == NULL)) { - if (EXPECTED(!EG(exception))) { - zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); - } - - - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - HANDLE_EXCEPTION(); - } - if (IS_CV == IS_CONST && - EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && - EXPECTED(obj == orig_obj)) { - CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); - } - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && UNEXPECTED(obj != orig_obj)) { - GC_ADDREF(obj); /* For $this pointer */ - if (GC_DELREF(orig_obj) == 0) { - zend_objects_store_del(orig_obj); - } - } - if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { - init_func_run_time_cache(&fbc->op_array); - } - } - - if (IS_CV != IS_CONST) { - - - } - - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS; - if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_STATIC) != 0)) { - if ((IS_TMP_VAR & (IS_VAR|IS_TMP_VAR)) && GC_DELREF(obj) == 0) { - zend_objects_store_del(obj); - if (UNEXPECTED(EG(exception))) { - HANDLE_EXCEPTION(); - } - } - /* call static method */ - obj = (zend_object*)called_scope; - call_info = ZEND_CALL_NESTED_FUNCTION; - } else if (IS_TMP_VAR & (IS_VAR|IS_TMP_VAR|IS_CV)) { - if (IS_TMP_VAR == IS_CV) { - GC_ADDREF(obj); /* For $this pointer */ - } - /* CV may be changed indirectly (e.g. when it's a reference) */ - call_info = ZEND_CALL_NESTED_FUNCTION | ZEND_CALL_HAS_THIS | ZEND_CALL_RELEASE_THIS; - } - - call = zend_vm_stack_push_call_frame(call_info, - fbc, opline->extended_value, obj); - call->prev_execute_data = EX(call); - EX(call) = call; - - ZEND_VM_NEXT_OPCODE(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - double d1, d2; - - op1 = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - op2 = EX_VAR(opline->op2.var); - if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - if (EXPECTED(Z_LVAL_P(op1) == Z_LVAL_P(op2))) { -case_true: - ZEND_VM_SMART_BRANCH_TRUE(); - } else { -case_false: - ZEND_VM_SMART_BRANCH_FALSE(); - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = (double)Z_LVAL_P(op1); - d2 = Z_DVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) { - d1 = Z_DVAL_P(op1); - d2 = Z_DVAL_P(op2); -case_double: - if (d1 == d2) { - goto case_true; - } else { - goto case_false; - } - } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { - d1 = Z_DVAL_P(op1); - d2 = (double)Z_LVAL_P(op2); - goto case_double; - } - } else if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { - if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { - bool result = zend_fast_equal_strings(Z_STR_P(op1), Z_STR_P(op2)); - - - if (result) { - goto case_true; - } else { - goto case_false; - } - } - } - ZEND_VM_DISPATCH_TO_HELPER(zend_case_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -75220,171 +78429,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_TM } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container; - bool result; - zend_ulong hval; - zval *offset; - - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = EX_VAR(opline->op2.var); - - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - HashTable *ht; - zval *value; - zend_string *str; - -isset_dim_obj_array: - ht = Z_ARRVAL_P(container); -isset_again: - if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { - str = Z_STR_P(offset); - if (IS_CV != IS_CONST) { - if (ZEND_HANDLE_NUMERIC(str, hval)) { - goto num_index_prop; - } - } - value = zend_hash_find_ex(ht, str, IS_CV == IS_CONST); - } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { - hval = Z_LVAL_P(offset); -num_index_prop: - value = zend_hash_index_find(ht, hval); - } else if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { - offset = Z_REFVAL_P(offset); - goto isset_again; - } else { - value = zend_find_array_dim_slow(ht, offset EXECUTE_DATA_CC); - if (UNEXPECTED(EG(exception))) { - result = 0; - goto isset_dim_obj_exit; - } - } - - if (!(opline->extended_value & ZEND_ISEMPTY)) { - /* > IS_NULL means not IS_UNDEF and not IS_NULL */ - result = value != NULL && Z_TYPE_P(value) > IS_NULL && - (!Z_ISREF_P(value) || Z_TYPE_P(Z_REFVAL_P(value)) != IS_NULL); - - if (IS_TMP_VAR & (IS_CONST|IS_CV)) { - /* avoid exception check */ - - - ZEND_VM_SMART_BRANCH(result, 0); - } - } else { - result = (value == NULL || !i_zend_is_true(value)); - } - goto isset_dim_obj_exit; - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(container))) { - container = Z_REFVAL_P(container); - if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { - goto isset_dim_obj_array; - } - } - - if (IS_CV == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { - offset++; - } - if (!(opline->extended_value & ZEND_ISEMPTY)) { - result = zend_isset_dim_slow(container, offset EXECUTE_DATA_CC); - } else { - result = zend_isempty_dim_slow(container, offset EXECUTE_DATA_CC); - } - -isset_dim_obj_exit: - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *container; - int result; - zval *offset; - zend_string *name, *tmp_name; - - SAVE_OPLINE(); - container = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); - - if (IS_TMP_VAR == IS_CONST || - (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { - container = Z_REFVAL_P(container); - if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; - } - } else { - result = (opline->extended_value & ZEND_ISEMPTY); - goto isset_object_finish; - } - } - - if (IS_CV == IS_CONST) { - name = Z_STR_P(offset); - } else { - name = zval_try_get_tmp_string(offset, &tmp_name); - if (UNEXPECTED(!name)) { - result = 0; - goto isset_object_finish; - } - } - - result = - (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - - if (IS_CV != IS_CONST) { - zend_tmp_string_release(tmp_name); - } - -isset_object_finish: - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - - zval *key, *subject; - HashTable *ht; - bool result; - - SAVE_OPLINE(); - - key = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); - subject = EX_VAR(opline->op2.var); - - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { -array_key_exists_array: - ht = Z_ARRVAL_P(subject); - result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); - } else { - if ((IS_CV & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { - subject = Z_REFVAL_P(subject); - if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { - goto array_key_exists_array; - } - } - zend_array_key_exists_error(subject, key OPLINE_CC EXECUTE_DATA_CC); - result = 0; - } - - - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_TMP_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -75774,6 +78818,88 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_D ZEND_VM_TAIL_CALL(zend_post_dec_helper_SPEC_VAR_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETURN_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + + retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + + + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + SAVE_OPLINE(); + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + + + + + + ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETURN_BY_REF_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -75839,8 +78965,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETURN_BY_REF_SPEC - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); } @@ -75890,6 +79014,153 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GENERATOR_RETURN_S ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_USER_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *arg, *param; + + SAVE_OPLINE(); + + arg = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + param = ZEND_CALL_VAR(EX(call), opline->result.var); + if (UNEXPECTED(ARG_MUST_BE_SENT_BY_REF(EX(call)->func, opline->op2.num))) { + zend_param_must_be_ref(EX(call)->func, opline->op2.num); + Z_TRY_ADDREF_P(arg); + ZVAL_NEW_REF(param, arg); + } else { + ZVAL_COPY(param, arg); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CAST_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *expr; + zval *result = EX_VAR(opline->result.var); + + SAVE_OPLINE(); + expr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + switch (opline->extended_value) { + case IS_LONG: + ZVAL_LONG(result, zval_get_long(expr)); + break; + case IS_DOUBLE: + ZVAL_DOUBLE(result, zval_get_double(expr)); + break; + case IS_STRING: + ZVAL_STR(result, zval_get_string(expr)); + break; + default: + ZEND_ASSERT(opline->extended_value != _IS_BOOL && "Must use ZEND_BOOL instead"); + if (IS_VAR & (IS_VAR|IS_CV)) { + ZVAL_DEREF(expr); + } + /* If value is already of correct type, return it directly */ + if (Z_TYPE_P(expr) == opline->extended_value) { + ZVAL_COPY_VALUE(result, expr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } + + if (opline->extended_value == IS_ARRAY) { + zend_cast_zval_to_array(result, expr, IS_VAR); + } else { + ZEND_ASSERT(opline->extended_value == IS_OBJECT); + zend_cast_zval_to_object(result, expr, IS_VAR); + } + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_R_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *array_ptr, *result; + + SAVE_OPLINE(); + + array_ptr = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(array_ptr) == IS_ARRAY)) { + result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, array_ptr); + if (IS_VAR != IS_TMP_VAR && Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(array_ptr); + } + Z_FE_POS_P(result) = 0; + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); + } else if (IS_VAR != IS_CONST && EXPECTED(Z_TYPE_P(array_ptr) == IS_OBJECT)) { + zend_object *zobj = Z_OBJ_P(array_ptr); + if (!zobj->ce->get_iterator) { + if (UNEXPECTED(zend_object_is_lazy(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (UNEXPECTED(EG(exception))) { + UNDEF_RESULT(); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + HANDLE_EXCEPTION(); + } + } + HashTable *properties = zobj->properties; + if (properties) { + if (UNEXPECTED(GC_REFCOUNT(properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(properties); + } + properties = zobj->properties = zend_array_dup(properties); + } + } else { + properties = zobj->handlers->get_properties(zobj); + } + + result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, array_ptr); + if (IS_VAR != IS_TMP_VAR) { + Z_ADDREF_P(array_ptr); + } + + if (zend_hash_num_elements(properties) == 0) { + Z_FE_ITER_P(result) = (uint32_t) -1; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + } + + Z_FE_ITER_P(result) = zend_hash_iterator_add(properties, 0); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + bool is_empty = zend_fe_reset_iterator(array_ptr, 0 OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + if (UNEXPECTED(EG(exception))) { + HANDLE_EXCEPTION(); + } else if (is_empty) { + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } else { + ZEND_VM_NEXT_OPCODE(); + } + } + } else { + zend_error(E_WARNING, "foreach() argument must be of type array|object, %s given", zend_zval_value_name(array_ptr)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + Z_FE_ITER_P(EX_VAR(opline->result.var)) = (uint32_t)-1; + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_JMP(OP_JMP_ADDR(opline, opline->op2)); + } +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_RW_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -75989,6 +79260,86 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_RESET_RW_SPEC_V } } +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_FETCH_R_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *array; + zval *value; + uint32_t value_type; + HashTable *fe_ht; + HashPosition pos; + + array = EX_VAR(opline->op1.var); + if (UNEXPECTED(Z_TYPE_P(array) != IS_ARRAY)) { + ZEND_VM_TAIL_CALL(zend_fe_fetch_object_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + } + fe_ht = Z_ARRVAL_P(array); + pos = Z_FE_POS_P(array); + if (HT_IS_PACKED(fe_ht)) { + value = fe_ht->arPacked + pos; + while (1) { + if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { + /* reached end of iteration */ + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } + value_type = Z_TYPE_INFO_P(value); + ZEND_ASSERT(value_type != IS_INDIRECT); + if (EXPECTED(value_type != IS_UNDEF)) { + break; + } + pos++; + value++; + } + Z_FE_POS_P(array) = pos + 1; + if (RETURN_VALUE_USED(opline)) { + ZVAL_LONG(EX_VAR(opline->result.var), pos); + } + } else { + Bucket *p; + + p = fe_ht->arData + pos; + while (1) { + if (UNEXPECTED(pos >= fe_ht->nNumUsed)) { + /* reached end of iteration */ + ZEND_VM_SET_RELATIVE_OPCODE(opline, opline->extended_value); + ZEND_VM_CONTINUE(); + } + pos++; + value = &p->val; + value_type = Z_TYPE_INFO_P(value); + ZEND_ASSERT(value_type != IS_INDIRECT); + if (EXPECTED(value_type != IS_UNDEF)) { + break; + } + p++; + } + Z_FE_POS_P(array) = pos; + if (RETURN_VALUE_USED(opline)) { + if (!p->key) { + ZVAL_LONG(EX_VAR(opline->result.var), p->h); + } else { + ZVAL_STR_COPY(EX_VAR(opline->result.var), p->key); + } + } + } + if (EXPECTED(opline->op2_type == IS_CV)) { + zval *variable_ptr = EX_VAR(opline->op2.var); + SAVE_OPLINE(); + zend_assign_to_variable(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES()); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + } else { + zval *res = EX_VAR(opline->op2.var); + zend_refcounted *gc = Z_COUNTED_P(value); + + ZVAL_COPY_VALUE_EX(res, value, gc, value_type); + if (Z_TYPE_INFO_REFCOUNTED(value_type)) { + GC_ADDREF(gc); + } + ZEND_VM_NEXT_OPCODE(); + } +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_FETCH_RW_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -76192,6 +79543,138 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FE_FETCH_RW_SPEC_V ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMP_SET_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zend_reference *ref = NULL; + bool ret; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + ref = Z_REF_P(value); + } + value = Z_REFVAL_P(value); + } + + ret = i_zend_is_true(value); + + if (UNEXPECTED(EG(exception))) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZVAL_UNDEF(EX_VAR(opline->result.var)); + HANDLE_EXCEPTION(); + } + + if (ret) { + zval *result = EX_VAR(opline->result.var); + + ZVAL_COPY_VALUE(result, value); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } else if (IS_VAR == IS_VAR && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_COALESCE_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zend_reference *ref = NULL; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if ((IS_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(value)) { + if (IS_VAR & IS_VAR) { + ref = Z_REF_P(value); + } + value = Z_REFVAL_P(value); + } + + if (Z_TYPE_P(value) > IS_NULL) { + zval *result = EX_VAR(opline->result.var); + ZVAL_COPY_VALUE(result, value); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(result))) Z_ADDREF_P(result); + } else if (IS_VAR == IS_CV) { + if (Z_OPT_REFCOUNTED_P(result)) Z_ADDREF_P(result); + } else if ((IS_VAR & IS_VAR) && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(result)) { + Z_ADDREF_P(result); + } + } + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); + } + + if ((IS_VAR & IS_VAR) && ref) { + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } + } + ZEND_VM_NEXT_OPCODE(); +} + +static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_JMP_NULL_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *val, *result; + + val = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (Z_TYPE_P(val) > IS_NULL) { + do { + if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) && Z_TYPE_P(val) == IS_REFERENCE) { + val = Z_REFVAL_P(val); + if (Z_TYPE_P(val) <= IS_NULL) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + break; + } + } + ZEND_VM_NEXT_OPCODE(); + } while (0); + } + + result = EX_VAR(opline->result.var); + uint32_t short_circuiting_type = opline->extended_value & ZEND_SHORT_CIRCUITING_CHAIN_MASK; + if (EXPECTED(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EXPR)) { + ZVAL_NULL(result); + if (IS_VAR == IS_CV + && UNEXPECTED(Z_TYPE_P(val) == IS_UNDEF) + && (opline->extended_value & ZEND_JMP_NULL_BP_VAR_IS) == 0 + ) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + } else if (short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_ISSET) { + ZVAL_FALSE(result); + } else { + ZEND_ASSERT(short_circuiting_type == ZEND_SHORT_CIRCUITING_CHAIN_EMPTY); + ZVAL_TRUE(result); + } + + ZEND_VM_JMP_EX(OP_JMP_ADDR(opline, opline->op2), 0); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_QM_ASSIGN_SPEC_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -76247,6 +79730,53 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_V ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_VAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_VAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_identical_function(op1, op2); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = RT_CONSTANT(opline, opline->op2); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -76340,7 +79870,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -76650,12 +80180,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_CONST == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -76729,12 +80253,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -76818,7 +80336,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -76936,7 +80454,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -76975,7 +80493,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -77091,7 +80609,162 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CONST == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + } else { + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CONST != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -77130,7 +80803,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -77248,7 +80921,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -77561,6 +81234,160 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CONST == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = RT_CONSTANT(opline, opline->op2); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = RT_CONSTANT(opline, opline->op2); + if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CONST == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = RT_CONSTANT(opline, opline->op2); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = RT_CONSTANT(opline, opline->op2); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = RT_CONSTANT(opline, 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) { + + + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -77814,7 +81641,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -77853,7 +81680,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -78829,6 +82656,78 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_VAR_CON ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IN_ARRAY_SPEC_VAR_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1; + HashTable *ht = Z_ARRVAL_P(RT_CONSTANT(opline, opline->op2)); + zval *result; + + op1 = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find_ex(ht, Z_STR_P(op1), IS_VAR == IS_CONST); + if (IS_VAR & (IS_TMP_VAR|IS_VAR)) { + zval_ptr_dtor_str(op1); + } + ZEND_VM_SMART_BRANCH(result, 0); + } + + if (opline->extended_value) { + if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + ZEND_VM_SMART_BRANCH(result, 0); + } + SAVE_OPLINE(); + if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find(ht, Z_STR_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { + result = zend_hash_index_find(ht, Z_LVAL_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } + } else if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + ZVAL_UNDEFINED_OP1(); + } + } else if (Z_TYPE_P(op1) <= IS_FALSE) { + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { + SAVE_OPLINE(); + ZVAL_UNDEFINED_OP1(); + if (UNEXPECTED(EG(exception) != NULL)) { + HANDLE_EXCEPTION(); + } + } + result = zend_hash_find_known_hash(ht, ZSTR_EMPTY_ALLOC()); + ZEND_VM_SMART_BRANCH(result, 0); + } else { + zend_string *key; + zval key_tmp; + + if ((IS_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(op1) == IS_REFERENCE) { + op1 = Z_REFVAL_P(op1); + if (EXPECTED(Z_TYPE_P(op1) == IS_STRING)) { + result = zend_hash_find(ht, Z_STR_P(op1)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(result, 0); + } + } + + SAVE_OPLINE(); + ZEND_HASH_MAP_FOREACH_STR_KEY(ht, key) { + ZVAL_STR(&key_tmp, key); + if (zend_compare(op1, &key_tmp) == 0) { + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(1, 1); + } + } ZEND_HASH_FOREACH_END(); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_SMART_BRANCH(0, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -78962,7 +82861,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_CONSTA ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -78977,7 +82876,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); @@ -78998,7 +82897,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC assign_op_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -79007,7 +82906,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -79042,7 +82941,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC } else { zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -79054,8 +82953,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *var_ptr; @@ -79070,15 +82969,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC SEPARATE_ARRAY(container); ht = Z_ARRVAL_P(container); assign_dim_op_new_array: - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_UNUSED) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC); } else { var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC); @@ -79091,7 +82990,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); do { - if (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { zend_reference *ref = Z_REF_P(var_ptr); var_ptr = Z_REFVAL_P(var_ptr); if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { @@ -79117,8 +83016,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { zend_object *obj = Z_OBJ_P(container); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC); @@ -79141,7 +83040,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC } goto assign_dim_op_new_array; } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -79156,14 +83055,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *var_ptr; zval *value; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); var_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); do { @@ -79187,7 +83086,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_SPEC_VAR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -79201,7 +83100,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_V SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -79220,7 +83119,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_V pre_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -79229,7 +83128,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_V break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -79243,7 +83142,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_V } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -79253,7 +83152,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_V ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -79267,7 +83166,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ SAVE_OPLINE(); object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -79286,7 +83185,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ post_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -79295,7 +83194,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { ZVAL_NULL(EX_VAR(opline->result.var)); @@ -79307,7 +83206,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -79317,14 +83216,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_W_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - zend_fetch_dimension_address_W(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_W(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -79332,14 +83231,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_W_SPEC_V ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - zend_fetch_dimension_address_RW(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_RW(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -79347,7 +83246,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_RW_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -79357,29 +83256,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -79387,7 +83280,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_UNSET_SP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; @@ -79395,11 +83288,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_V SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); zend_fetch_property_address( - result, container, IS_VAR, property, IS_TMP_VAR, - ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), + result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { @@ -79408,16 +83301,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_V ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_VAR, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -79425,7 +83318,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -79436,28 +83329,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *property, *result; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_VAR, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_VAR == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -79465,30 +83352,30 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_LIST_W_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *dim; SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_VAR == IS_VAR && Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT && UNEXPECTED(!Z_ISREF_P(container)) ) { zend_error(E_NOTICE, "Attempting to set reference to non referenceable value"); - zend_fetch_dimension_address_LIST_r(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_LIST_r(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } else { - zend_fetch_dimension_address_W(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_W(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -79505,14 +83392,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -79526,7 +83413,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -79538,7 +83425,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -79606,9 +83493,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -79621,9 +83508,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -79643,8 +83530,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -79661,14 +83548,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -79682,7 +83569,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -79694,7 +83581,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -79762,9 +83649,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -79776,9 +83663,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -79797,8 +83838,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -79815,14 +83856,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -79836,7 +83877,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -79848,7 +83889,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -79916,9 +83957,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -79931,9 +83972,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -79953,8 +83994,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -79969,7 +84010,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { value = RT_CONSTANT((opline+1), (opline+1)->op1); if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); @@ -80007,8 +84048,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -80036,10 +84077,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } @@ -80057,13 +84098,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value = RT_CONSTANT((opline+1), (opline+1)->op1); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); @@ -80073,7 +84114,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); UNDEF_RESULT(); @@ -80094,7 +84135,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -80103,7 +84144,160 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } } } - if (IS_TMP_VAR != IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + 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) { + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_TMP_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_TMP_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); +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(EX_VAR(opline->op2.var)); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -80111,7 +84305,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -80126,9 +84320,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { GC_ADDREF(ht); @@ -80139,18 +84333,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA goto assign_dim_error; } } - if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { ZVAL_DEREF(value); } value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); if (UNEXPECTED(value == NULL)) { zend_cannot_add_element(); goto assign_dim_error; - } else if (IS_TMP_VAR == IS_CV) { + } else if (IS_VAR == IS_CV) { if (Z_REFCOUNTED_P(value)) { Z_ADDREF_P(value); } - } else if (IS_TMP_VAR == IS_VAR) { + } else if (IS_VAR == IS_VAR) { zval *free_op_data = EX_VAR((opline+1)->op1.var); if (Z_ISREF_P(free_op_data)) { if (Z_REFCOUNTED_P(value)) { @@ -80158,14 +84352,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } zval_ptr_dtor_nogc(free_op_data); } - } else if (IS_TMP_VAR == IS_CONST) { + } else if (IS_VAR == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(value))) { Z_ADDREF_P(value); } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -80173,8 +84367,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA if (UNEXPECTED(variable_ptr == NULL)) { goto assign_dim_error; } - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); } if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); @@ -80193,17 +84387,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) { + } else if (IS_VAR & (IS_CV|IS_VAR)) { ZVAL_DEREF(value); } @@ -80214,13 +84408,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } @@ -80228,7 +84422,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { @@ -80248,7 +84442,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -80256,7 +84450,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } } } - if (IS_TMP_VAR != IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -80264,7 +84458,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -80279,7 +84473,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { value = EX_VAR((opline+1)->op1.var); if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); @@ -80317,8 +84511,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -80346,10 +84540,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } @@ -80367,13 +84561,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value = EX_VAR((opline+1)->op1.var); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); @@ -80383,7 +84577,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); UNDEF_RESULT(); @@ -80404,7 +84598,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -80413,7 +84607,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA } } } - if (IS_TMP_VAR != IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -80421,65 +84615,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - zval *variable_ptr; - - SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if (0 || UNEXPECTED(0)) { - zend_refcounted *garbage = NULL; - - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(0)) { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (garbage) { - GC_DTOR_NO_REF(garbage); - } - } else { - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - /* zend_assign_to_variable() always takes care of op2, never free it! */ - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *value; - zval *variable_ptr; - - SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - - if (0 || UNEXPECTED(1)) { - zend_refcounted *garbage = NULL; - - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(1)) { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (garbage) { - GC_DTOR_NO_REF(garbage); - } - } else { - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); - } - zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); - /* zend_assign_to_variable() always takes care of op2, never free it! */ - - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -80487,26 +84623,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_VAR == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_VAR, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -80515,8 +84651,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -80524,26 +84660,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_VAR == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_VAR, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_VAR, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); @@ -80553,8 +84689,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -80574,7 +84710,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { CACHE_PTR(opline->result.num, ce); } } @@ -80589,24 +84725,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD } if (IS_VAR == IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { /* nothing to do */ } else if (IS_VAR != IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == ce)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_TMP_VAR != IS_UNUSED) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if (IS_TMP_VAR & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -80622,7 +84758,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name)); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { @@ -80631,7 +84767,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) { CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); @@ -80639,7 +84775,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } } else { @@ -80687,7 +84823,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *expr_ptr, new_expr; @@ -80727,15 +84863,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ } } - if (IS_TMP_VAR != IS_UNUSED) { - zval *offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_string *str; zend_ulong hval; add_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index; } @@ -80746,7 +84882,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ hval = Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto add_again; } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { @@ -80779,7 +84915,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -80797,7 +84933,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -80812,14 +84948,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_VA if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { zend_hash_real_init_mixed(Z_ARRVAL_P(array)); } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { ZVAL_ARR(array, zend_new_array(0)); ZEND_VM_NEXT_OPCODE(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -80829,7 +84965,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_VAR SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -80841,7 +84977,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_VAR offset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { key = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(key, hval)) { goto num_index_dim; } @@ -80853,7 +84989,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_VAR hval = Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { @@ -80882,7 +85018,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_VAR zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); goto str_index_dim; @@ -80899,11 +85035,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_VAR if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { container = ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = ZVAL_UNDEFINED_OP2(); } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset); @@ -80921,7 +85057,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_VAR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -80930,7 +85066,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_VAR SAVE_OPLINE(); container = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -80947,7 +85083,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_VAR break; } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -80955,8 +85091,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_VAR break; } } - Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -80966,7 +85102,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_VAR ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_VAR_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -81052,9 +85188,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_VAR_TMP } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -81087,6 +85223,210 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_VAR_TMP ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (0 || UNEXPECTED(0)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (0 || UNEXPECTED(1)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_VAR_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_VAR_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (0 || UNEXPECTED(0)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (0 || UNEXPECTED(1)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_VAR_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -81274,12 +85614,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_UNUSED == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -81596,6 +85930,160 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_UNUSED == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = NULL; + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = NULL; + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_UNUSED == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = NULL; + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = NULL; + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_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) { + + + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -82393,17 +86881,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NEW_SPEC_VAR_UNUSE zend_function *constructor; zend_class_entry *ce; zend_execute_data *call; + uint32_t cache_slot; + bool has_generic_args = false; SAVE_OPLINE(); if (IS_VAR == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); + cache_slot = opline->op2.num & 0x7FFFFFFF; + has_generic_args = (opline->op2.num & 0x80000000) != 0; + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - CACHE_PTR(opline->op2.num, ce); + CACHE_PTR(cache_slot, ce); } } else if (IS_VAR == IS_UNUSED) { ce = zend_fetch_class(NULL, opline->op1.num); @@ -82421,6 +86913,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NEW_SPEC_VAR_UNUSE HANDLE_EXCEPTION(); } + /* Bind generic type arguments to the newly created object */ + if (has_generic_args) { + /* Generic args literal is stored at op1.constant + 2 + * (after class name + lowercase class name) */ + zval *generic_args_zv = RT_CONSTANT(opline, opline->op1) + 2; + zend_generic_args *compiled_args = (zend_generic_args *) Z_PTR_P(generic_args_zv); + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(compiled_args); + /* Verify type arguments satisfy constraints (e.g., T: Countable) */ + if (ce->generic_params_info) { + zend_verify_generic_args(ce->generic_params_info, Z_OBJ_P(result)->generic_args); + } + } else if (ce->bound_generic_args) { + /* Inherit bound generic args from class (e.g., IntList extends Collection) */ + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(ce->bound_generic_args); + } + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next @@ -82757,6 +87265,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_MAKE_REF_SPEC_VAR_ ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_GET_TYPE_SPEC_VAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1; + zend_string *type; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + type = zend_zval_get_legacy_type(op1); + if (EXPECTED(type)) { + ZVAL_INTERNED_STR(EX_VAR(opline->result.var), type); + } else { + ZVAL_STRING(EX_VAR(opline->result.var), "unknown type"); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -82779,6 +87305,21 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SEND_V ZEND_VM_NEXT_OPCODE(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CASE_STRICT_SPEC_VAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_var_deref(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + + + ZEND_VM_SMART_BRANCH(result, 1); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -82872,7 +87413,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -83182,12 +87723,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_CV == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_VAR & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -83261,12 +87796,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_VAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_VAR == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -83350,7 +87879,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -83468,7 +87997,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -83507,7 +88036,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -83623,7 +88152,162 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_VAR != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CV == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -83662,7 +88346,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -83780,7 +88464,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -84093,6 +88777,160 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VA ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CV == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CV == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = EX_VAR(opline->op2.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); +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) { + + + } + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -84385,7 +89223,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CV_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -84424,7 +89262,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -85326,7 +90164,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -85467,15 +90305,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND SAVE_OPLINE(); container = &EX(This); - if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_UNUSED & IS_CV) && Z_ISREF_P(container)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -85688,8 +90522,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ SAVE_OPLINE(); container = &EX(This); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -85818,12 +90650,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_UNUSED == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -85884,7 +90710,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -86003,7 +90829,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -86042,7 +90868,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -86159,7 +90985,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = &EX(This); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CONST == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + } else { + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CONST != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -86198,7 +91180,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -86317,7 +91299,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -86355,7 +91337,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -86394,7 +91376,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_INIT_SPEC_UNUSED_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -87341,7 +92323,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_CONSTA ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -87356,7 +92338,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC SAVE_OPLINE(); object = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); @@ -87377,7 +92359,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC assign_op_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -87386,7 +92368,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -87421,7 +92403,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC } else { zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -87434,8 +92416,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -87449,7 +92431,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_U SAVE_OPLINE(); object = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -87468,7 +92450,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_U pre_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -87477,7 +92459,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_U break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -87491,7 +92473,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_U } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -87502,7 +92484,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_U ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -87516,7 +92498,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ SAVE_OPLINE(); object = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -87535,7 +92517,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ post_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -87544,7 +92526,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { ZVAL_NULL(EX_VAR(opline->result.var)); @@ -87556,7 +92538,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -87567,7 +92549,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -87575,15 +92557,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_U SAVE_OPLINE(); container = &EX(This); - if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_UNUSED & IS_CV) && Z_ISREF_P(container)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -87592,7 +92570,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_U if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_wrong_property_read(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); ZVAL_NULL(EX_VAR(opline->result.var)); goto fetch_obj_r_finish; } while (0); @@ -87604,7 +92582,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_U zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -87664,7 +92642,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_U /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -87697,9 +92675,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_U } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -87723,7 +92701,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_U } #endif - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -87742,7 +92720,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_U ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; @@ -87750,11 +92728,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_U SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); zend_fetch_property_address( - result, container, IS_UNUSED, property, IS_TMP_VAR, - ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), + result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_UNUSED == IS_VAR) { @@ -87763,16 +92741,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_U ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_UNUSED, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_UNUSED == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -87780,7 +92758,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -87788,8 +92766,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ SAVE_OPLINE(); container = &EX(This); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -87800,7 +92776,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ break; } } - if (IS_TMP_VAR == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(EX_VAR(opline->result.var)); @@ -87814,7 +92790,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -87841,7 +92817,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -87874,9 +92850,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -87885,7 +92861,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -87904,7 +92880,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -87915,28 +92891,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG if ((IS_UNUSED & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_UNUSED == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *property, *result; SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_UNUSED, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_UNUSED == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -87944,7 +92914,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -87961,14 +92931,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -87982,7 +92952,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -87994,7 +92964,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -88062,9 +93032,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -88077,9 +93047,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -88100,8 +93070,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -88118,14 +93088,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -88139,7 +93109,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -88151,7 +93121,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -88219,9 +93189,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -88233,9 +93203,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -88255,8 +93225,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = &EX(This); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -88273,14 +93398,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -88294,7 +93419,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -88306,7 +93431,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -88374,9 +93499,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -88389,9 +93514,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -88412,8 +93537,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -88421,26 +93546,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_UNUSED == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_UNUSED, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } @@ -88449,8 +93574,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -88458,26 +93583,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE SAVE_OPLINE(); container = &EX(This); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_UNUSED == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_UNUSED, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_UNUSED, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } @@ -88487,8 +93612,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_INIT_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zend_string **rope; @@ -88496,23 +93621,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_INIT_SPEC_UNU /* Compiler allocates the necessary number of zval slots to keep the rope */ rope = (zend_string**)EX_VAR(opline->result.var); - if (IS_TMP_VAR == IS_CONST) { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); rope[0] = Z_STR_P(var); if (UNEXPECTED(Z_REFCOUNTED_P(var))) { Z_ADDREF_P(var); } } else { - var = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + var = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(var) == IS_STRING)) { - if (IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { rope[0] = zend_string_copy(Z_STR_P(var)); } else { rope[0] = Z_STR_P(var); } } else { SAVE_OPLINE(); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(var) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } rope[0] = zval_get_string_func(var); @@ -88523,36 +93648,36 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_INIT_SPEC_UNU ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *class_name; USE_OPLINE SAVE_OPLINE(); - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->op1.num); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); - } else if (IS_TMP_VAR == IS_CONST) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_class_entry *ce = CACHED_PTR(opline->extended_value); if (UNEXPECTED(ce == NULL)) { - class_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); ce = zend_fetch_class_by_name(Z_STR_P(class_name), Z_STR_P(class_name + 1), opline->op1.num); CACHE_PTR(opline->extended_value, ce); } Z_CE_P(EX_VAR(opline->result.var)) = ce; } else { - class_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + class_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); try_class_name: if (Z_TYPE_P(class_name) == IS_OBJECT) { Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name); } else if (Z_TYPE_P(class_name) == IS_STRING) { Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->op1.num); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_TYPE_P(class_name) == IS_REFERENCE) { class_name = Z_REFVAL_P(class_name); goto try_class_name; } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(class_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -88566,7 +93691,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_CLASS_SPEC_U ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -88581,19 +93706,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S object = &EX(This); - if (IS_TMP_VAR != IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST && + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { @@ -88635,14 +93760,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S if (IS_UNUSED == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { object = ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } HANDLE_EXCEPTION(); } } - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -88655,18 +93780,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S called_scope = obj->ce; - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { zend_object *orig_obj = obj; - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); @@ -88677,7 +93802,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S } HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(obj == orig_obj)) { CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); @@ -88693,7 +93818,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -88724,7 +93849,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -88744,7 +93869,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { CACHE_PTR(opline->result.num, ce); } } @@ -88759,24 +93884,24 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD } if (IS_UNUSED == IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED((fbc = CACHED_PTR(opline->result.num + sizeof(void*))) != NULL)) { /* nothing to do */ } else if (IS_UNUSED != IS_CONST && - IS_TMP_VAR == IS_CONST && + (IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == ce)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); - } else if (IS_TMP_VAR != IS_UNUSED) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if (IS_TMP_VAR & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { HANDLE_EXCEPTION(); @@ -88792,7 +93917,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD if (ce->get_static_method) { fbc = ce->get_static_method(ce, Z_STR_P(function_name)); } else { - fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); } if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { @@ -88801,7 +93926,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(!(fbc->common.scope->ce_flags & ZEND_ACC_TRAIT))) { CACHE_POLYMORPHIC_PTR(opline->result.num, ce, fbc); @@ -88809,7 +93934,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD if (EXPECTED(fbc->type == ZEND_USER_FUNCTION) && UNEXPECTED(!RUN_TIME_CACHE(&fbc->op_array))) { init_func_run_time_cache(&fbc->op_array); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } } else { @@ -88857,7 +93982,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_STATIC_METHOD ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -88879,7 +94004,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_UN } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -88888,7 +94013,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_UNU SAVE_OPLINE(); container = &EX(This); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -88905,7 +94030,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_UNU break; } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -88913,8 +94038,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_UNU break; } } - Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -88925,7 +94050,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_UNU ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -88935,7 +94060,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP SAVE_OPLINE(); container = &EX(This); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -88951,7 +94076,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -88963,9 +94088,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP result = (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -88976,7 +94101,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_UNUSED_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -89063,9 +94188,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_UNUSED_ } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -89438,17 +94563,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NEW_SPEC_UNUSED_UN zend_function *constructor; zend_class_entry *ce; zend_execute_data *call; + uint32_t cache_slot; + bool has_generic_args = false; SAVE_OPLINE(); if (IS_UNUSED == IS_CONST) { - ce = CACHED_PTR(opline->op2.num); + cache_slot = opline->op2.num & 0x7FFFFFFF; + has_generic_args = (opline->op2.num & 0x80000000) != 0; + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_fetch_class_by_name(Z_STR_P(RT_CONSTANT(opline, opline->op1)), Z_STR_P(RT_CONSTANT(opline, opline->op1) + 1), ZEND_FETCH_CLASS_DEFAULT | ZEND_FETCH_CLASS_EXCEPTION); if (UNEXPECTED(ce == NULL)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); HANDLE_EXCEPTION(); } - CACHE_PTR(opline->op2.num, ce); + CACHE_PTR(cache_slot, ce); } } else if (IS_UNUSED == IS_UNUSED) { ce = zend_fetch_class(NULL, opline->op1.num); @@ -89466,6 +94595,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NEW_SPEC_UNUSED_UN HANDLE_EXCEPTION(); } + /* Bind generic type arguments to the newly created object */ + if (has_generic_args) { + /* Generic args literal is stored at op1.constant + 2 + * (after class name + lowercase class name) */ + zval *generic_args_zv = RT_CONSTANT(opline, opline->op1) + 2; + zend_generic_args *compiled_args = (zend_generic_args *) Z_PTR_P(generic_args_zv); + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(compiled_args); + /* Verify type arguments satisfy constraints (e.g., T: Countable) */ + if (ce->generic_params_info) { + zend_verify_generic_args(ce->generic_params_info, Z_OBJ_P(result)->generic_args); + } + } else if (ce->bound_generic_args) { + /* Inherit bound generic args from class (e.g., IntList extends Collection) */ + Z_OBJ_P(result)->generic_args = zend_copy_generic_args(ce->bound_generic_args); + } + constructor = Z_OBJ_HT_P(result)->get_constructor(Z_OBJ_P(result)); if (constructor == NULL) { /* If there are no arguments, skip over the DO_FCALL opcode. We check if the next @@ -89831,27 +94976,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CALLABLE_CONVERT_S USE_OPLINE zend_execute_data *call = EX(call); - if (opline->extended_value != (uint32_t)-1) { - zend_object *closure = CACHED_PTR(opline->extended_value); - if (closure) { - ZVAL_OBJ_COPY(EX_VAR(opline->result.var), closure); - } else { - /* Rotate the key for better hash distribution. */ - const int shift = sizeof(size_t) == 4 ? 6 : 7; - zend_ulong key = (zend_ulong)(uintptr_t)call->func; - key = (key >> shift) | (key << ((sizeof(key) * 8) - shift)); - zval *closure_zv = zend_hash_index_lookup(&EG(callable_convert_cache), key); - if (Z_TYPE_P(closure_zv) == IS_NULL) { - zend_closure_from_frame(closure_zv, call); - } - ZEND_ASSERT(Z_TYPE_P(closure_zv) == IS_OBJECT); - closure = Z_OBJ_P(closure_zv); - ZVAL_OBJ_COPY(EX_VAR(opline->result.var), closure); - CACHE_PTR(opline->extended_value, closure); - } - } else { - zend_closure_from_frame(EX_VAR(opline->result.var), call); - } + zend_closure_from_frame(EX_VAR(opline->result.var), call); if (ZEND_CALL_INFO(call) & ZEND_CALL_RELEASE_THIS) { OBJ_RELEASE(Z_OBJ(call->This)); @@ -89879,7 +95004,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FRAMELESS_ICALL_0_ #endif { zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline); - function(result); + function(EX_VAR(opline->result.var)); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -89899,7 +95024,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FRAMELESS_ICALL_0_ #endif { zend_frameless_function_0 function = (zend_frameless_function_0)ZEND_FLF_HANDLER(opline); - function(result); + function(EX_VAR(opline->result.var)); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } @@ -89998,7 +95123,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -90139,15 +95264,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_U SAVE_OPLINE(); container = &EX(This); - if (IS_UNUSED & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_UNUSED & IS_CV) && Z_ISREF_P(container)) { + if ((IS_UNUSED & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -90355,8 +95476,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ SAVE_OPLINE(); container = &EX(This); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_UNUSED == IS_CONST || (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -90485,12 +95604,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_UNUSED == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -90551,7 +95664,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -90670,7 +95783,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -90709,7 +95822,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -90826,7 +95939,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = &EX(This); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_UNUSED != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CV == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -90865,7 +96134,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -90984,7 +96253,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_UN ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -91022,7 +96291,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CV_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -91061,7 +96330,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ROPE_INIT_SPEC_UNUSED_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -92265,8 +97534,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_RETURN_BY_REF_SPEC - zend_return_unwrap_ref(execute_data, return_value); - ZEND_VM_DISPATCH_TO_LEAVE_HELPER(zend_leave_helper_SPEC_TAILCALL); } @@ -92345,8 +97612,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_THROW_SPEC_CV_TAIL } } while (0); + zend_exception_save(); Z_TRY_ADDREF_P(value); zend_throw_exception_object(value); + zend_exception_restore(); HANDLE_EXCEPTION(); @@ -94097,7 +99366,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -94371,17 +99640,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_C SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } dim = RT_CONSTANT(opline, opline->op2); if (IS_CV != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CONST, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CV == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -94444,8 +99709,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_ SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ zend_fetch_dimension_address_read_IS(container, RT_CONSTANT(opline, opline->op2), IS_CONST OPLINE_CC EXECUTE_DATA_CC); @@ -94469,12 +99732,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_CONST == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CV & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -94503,15 +99760,11 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CV & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -94724,8 +99977,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -94854,12 +100105,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CV == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -94920,7 +100165,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -95039,7 +100284,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -95078,7 +100323,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -95195,7 +100440,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = EX_VAR(opline->op1.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, RT_CONSTANT(opline, opline->op2) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CONST == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(RT_CONSTANT(opline, opline->op2)); + } else { + name = zval_try_get_tmp_string(RT_CONSTANT(opline, opline->op2), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CONST == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CONST != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -95234,7 +100635,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -95353,7 +100754,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -95668,6 +101069,161 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CONST == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = RT_CONSTANT(opline, opline->op2); + if (IS_CONST == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = RT_CONSTANT(opline, opline->op2); + if (IS_CONST == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CONST == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CONST == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = RT_CONSTANT(opline, opline->op2); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = RT_CONSTANT(opline, opline->op2); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = RT_CONSTANT(opline, 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); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -95924,7 +101480,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -95963,7 +101519,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_CV_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -96863,13 +102419,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_CV try_instanceof: if (Z_TYPE_P(expr) == IS_OBJECT) { zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; if (IS_CONST == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); + CACHE_PTR(cache_slot, ce); } } } else if (IS_CONST == IS_UNUSED) { @@ -96884,6 +102441,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_CV ce = Z_CE_P(EX_VAR(opline->op2.var)); } result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_CONST == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { expr = Z_REFVAL_P(expr); goto try_instanceof; @@ -97324,14 +102896,14 @@ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); div_function(EX_VAR(opline->result.var), op1, op2); @@ -97339,14 +102911,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_DIV_SPEC_CV_TMP_TA ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); pow_function(EX_VAR(opline->result.var), op1, op2); @@ -97354,23 +102926,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POW_SPEC_CV_TMP_TA ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); @@ -97378,13 +102950,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CV_TMP if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CV == IS_CONST || IS_CV == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else if (IS_CV != IS_CONST && IS_CV != IS_CV && @@ -97398,7 +102970,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CV_TMP memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -97410,7 +102982,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CV_TMP if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } @@ -97421,7 +102993,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CV_TMP if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(op1) == IS_UNDEF)) { op1 = ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { op2 = ZVAL_UNDEFINED_OP2(); } concat_function(EX_VAR(opline->result.var), op1, op2); @@ -97432,47 +103004,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_CONCAT_SPEC_CV_TMP } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_identical_function(op1, op2); - - - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *op1, *op2; - bool result; - - SAVE_OPLINE(); - op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - result = fast_is_not_identical_function(op1, op2); - - - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - ZEND_VM_SMART_BRANCH(result, 1); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -97509,7 +103049,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_T if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (result) { @@ -97522,15 +103062,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_T ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -97567,7 +103107,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_T if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (result) { @@ -97580,15 +103120,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_T ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -97625,7 +103165,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_T if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (result) { @@ -97638,15 +103178,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_EQUAL_SPEC_CV_T ZEND_VM_DISPATCH_TO_HELPER(zend_is_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -97683,7 +103223,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_ if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (!result) { @@ -97696,15 +103236,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_ ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -97741,7 +103281,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_ if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (!result) { @@ -97754,15 +103294,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_ ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; double d1, d2; op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (1 && IS_CV == IS_CONST && IS_TMP_VAR == IS_CONST) { + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (1 && IS_CV == IS_CONST && (IS_TMP_VAR|IS_VAR) == IS_CONST) { /* pass */ } else if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) { if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) { @@ -97799,7 +103339,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_ if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op1); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zval_ptr_dtor_str(op2); } if (!result) { @@ -97812,14 +103352,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_EQUAL_SPEC_ ZEND_VM_DISPATCH_TO_HELPER(zend_is_not_equal_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX op1, op2)); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); compare_function(EX_VAR(opline->result.var), op1, op2); @@ -97827,14 +103367,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_SPACESHIP_SPEC_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_XOR_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_XOR_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; SAVE_OPLINE(); op1 = _get_zval_ptr_cv_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); boolean_xor_function(EX_VAR(opline->result.var), op1, op2); @@ -97842,7 +103382,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_BOOL_XOR_SPEC_CV_T ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -97857,7 +103397,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC SAVE_OPLINE(); object = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); @@ -97878,7 +103418,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC assign_op_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -97887,7 +103427,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR((opline+1)->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -97922,7 +103462,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC } else { zend_assign_op_overloaded_property(zobj, name, cache_slot, value OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -97935,8 +103475,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *var_ptr; @@ -97951,15 +103491,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC SEPARATE_ARRAY(container); ht = Z_ARRVAL_P(container); assign_dim_op_new_array: - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_UNUSED) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { var_ptr = zend_hash_next_index_insert(ht, &EG(uninitialized_zval)); if (UNEXPECTED(!var_ptr)) { zend_cannot_add_element(); goto assign_dim_op_ret_null; } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { var_ptr = zend_fetch_dimension_address_inner_RW_CONST(ht, dim EXECUTE_DATA_CC); } else { var_ptr = zend_fetch_dimension_address_inner_RW(ht, dim EXECUTE_DATA_CC); @@ -97972,7 +103512,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC value = get_op_data_zval_ptr_r((opline+1)->op1_type, (opline+1)->op1); do { - if (IS_TMP_VAR != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED && UNEXPECTED(Z_ISREF_P(var_ptr))) { zend_reference *ref = Z_REF_P(var_ptr); var_ptr = Z_REFVAL_P(var_ptr); if (UNEXPECTED(ZEND_REF_HAS_TYPE_SOURCES(ref))) { @@ -97998,8 +103538,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { zend_object *obj = Z_OBJ_P(container); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_binary_assign_op_obj_dim(obj, dim OPLINE_CC EXECUTE_DATA_CC); @@ -98022,7 +103562,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC } goto assign_dim_op_new_array; } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_binary_assign_op_dim_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); assign_dim_op_ret_null: FREE_OP((opline+1)->op1_type, (opline+1)->op1.var); @@ -98038,14 +103578,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *var_ptr; zval *value; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); var_ptr = _get_zval_ptr_cv_BP_VAR_RW(opline->op1.var EXECUTE_DATA_CC); do { @@ -98070,7 +103610,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OP_SPEC_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -98084,7 +103624,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_C SAVE_OPLINE(); object = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -98103,7 +103643,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_C pre_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -98112,7 +103652,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_C break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { if (UNEXPECTED(RETURN_VALUE_USED(opline))) { @@ -98126,7 +103666,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_C } else { zend_pre_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -98137,7 +103677,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_PRE_INC_OBJ_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object; @@ -98151,7 +103691,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ SAVE_OPLINE(); object = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { @@ -98170,7 +103710,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ post_incdec_object: /* here we are sure we are dealing with an object */ zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(property); } else { name = zval_try_get_tmp_string(property, &tmp_name); @@ -98179,7 +103719,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ break; } } - cache_slot = (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; + cache_slot = ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : _cache_slot; if (EXPECTED((zptr = zobj->handlers->get_property_ptr_ptr(zobj, name, BP_VAR_RW, cache_slot)) != NULL)) { if (UNEXPECTED(Z_ISERROR_P(zptr))) { ZVAL_NULL(EX_VAR(opline->result.var)); @@ -98191,7 +103731,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ } else { zend_post_incdec_overloaded_property(zobj, name, cache_slot OPLINE_CC EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -98202,24 +103742,20 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_POST_INC_OBJ_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *dim, *value; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_CV != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: - value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_TMP_VAR, BP_VAR_R EXECUTE_DATA_CC); + value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, (IS_TMP_VAR|IS_VAR), BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CV == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -98228,13 +103764,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_C } } else { fetch_dim_r_slow: - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } zend_fetch_dimension_address_read_R_slow(container, dim OPLINE_CC EXECUTE_DATA_CC); } } else { - zend_fetch_dimension_address_read_R(container, dim, IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_R(container, dim, (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); } zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -98242,14 +103778,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_W_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - zend_fetch_dimension_address_W(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_W(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -98257,14 +103793,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_W_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_RW_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - zend_fetch_dimension_address_RW(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_RW(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -98272,23 +103808,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_RW_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ - zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_read_IS(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -98298,29 +103832,23 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CV & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), IS_TMP_VAR OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_dimension_address_UNSET(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), (IS_TMP_VAR|IS_VAR) OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -98328,7 +103856,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_UNSET_SP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -98336,15 +103864,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_C SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CV & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -98353,7 +103877,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_C if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } - zend_wrong_property_read(container, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + zend_wrong_property_read(container, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); ZVAL_NULL(EX_VAR(opline->result.var)); goto fetch_obj_r_finish; } while (0); @@ -98365,7 +103889,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_C zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_REF /* FUNC_ARG fetch may contain it */); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -98425,7 +103949,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_C /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -98458,9 +103982,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_C } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -98484,7 +104008,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_C } #endif - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -98503,7 +104027,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; @@ -98511,11 +104035,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_C SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); zend_fetch_property_address( - result, container, IS_CV, property, IS_TMP_VAR, - ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), + result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), + (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS) : NULL), BP_VAR_W, opline->extended_value, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { @@ -98524,16 +104048,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_W_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *result; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_CV, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_RW, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -98541,7 +104065,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_RW_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -98549,8 +104073,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -98561,7 +104083,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ break; } } - if (IS_TMP_VAR == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(EX_VAR(opline->op2.var)) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); } ZVAL_NULL(EX_VAR(opline->result.var)); @@ -98575,7 +104097,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ zend_string *name, *tmp_name; zval *retval; - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { cache_slot = CACHE_ADDR(opline->extended_value); if (EXPECTED(zobj->ce == CACHED_PTR_EX(cache_slot))) { @@ -98602,7 +104124,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ /* Fall through to read_property for hooks. */ } else if (EXPECTED(zobj->properties != NULL)) { ZEND_ASSERT(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset)); - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(prop_offset)) { uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(prop_offset); @@ -98635,9 +104157,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ } } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { ZVAL_UNDEF(EX_VAR(opline->result.var)); break; @@ -98646,7 +104168,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ retval = zobj->handlers->read_property(zobj, name, BP_VAR_IS, cache_slot, EX_VAR(opline->result.var)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -98665,7 +104187,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { #if 0 USE_OPLINE @@ -98676,28 +104198,22 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG if ((IS_CV & (IS_CONST|IS_TMP_VAR))) { ZEND_VM_TAIL_CALL(zend_use_tmp_in_write_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CV == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } - ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container, *property, *result; SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); result = EX_VAR(opline->result.var); - zend_fetch_property_address(result, container, IS_CV, property, IS_TMP_VAR, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); + zend_fetch_property_address(result, container, IS_CV, property, (IS_TMP_VAR|IS_VAR), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL), BP_VAR_UNSET, 0, NULL OPLINE_CC EXECUTE_DATA_CC); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); if (IS_CV == IS_VAR) { FREE_VAR_PTR_AND_EXTRACT_RESULT_IF_NECESSARY(opline->op1.var); @@ -98705,7 +104221,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_UNSET_SP ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -98722,14 +104238,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -98743,7 +104259,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -98755,7 +104271,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -98823,9 +104339,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -98838,9 +104354,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -98861,8 +104377,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -98879,14 +104395,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -98900,7 +104416,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -98912,7 +104428,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -98980,9 +104496,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); @@ -98994,9 +104510,164 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = EX_VAR(opline->op1.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -99016,8 +104687,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object, *value, tmp; @@ -99034,14 +104705,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV object = Z_REFVAL_P(object); goto assign_object; } - zend_throw_non_object_error(object, _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + zend_throw_non_object_error(object, _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); value = &EG(uninitialized_zval); goto free_and_exit_assign_obj; } assign_object: zobj = Z_OBJ_P(object); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { void **cache_slot = CACHE_ADDR(opline->extended_value); uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); @@ -99055,7 +104726,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -99067,7 +104738,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV } } } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { zobj = zend_lazy_object_init(zobj); if (!zobj) { @@ -99135,9 +104806,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV /* Fall through to write_property for hooks. */ } } - name = Z_STR_P(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC)); + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); } else { - name = zval_try_get_tmp_string(_get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + name = zval_try_get_tmp_string(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC), &tmp_name); if (UNEXPECTED(!name)) { @@ -99150,9 +104821,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZVAL_DEREF(value); } - value = zobj->handlers->write_property(zobj, name, value, (IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + value = zobj->handlers->write_property(zobj, name, value, ((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -99173,8 +104844,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -99189,7 +104860,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { value = RT_CONSTANT((opline+1), (opline+1)->op1); if (IS_CONST == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); @@ -99227,8 +104898,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -99256,10 +104927,10 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } @@ -99277,13 +104948,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value = RT_CONSTANT((opline+1), (opline+1)->op1); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); @@ -99293,7 +104964,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); UNDEF_RESULT(); @@ -99314,7 +104985,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); assign_dim_error: @@ -99323,7 +104994,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV } } } - if (IS_TMP_VAR != IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -99332,7 +105003,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *object_ptr, *orig_object_ptr; @@ -99347,7 +105018,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { try_assign_dim_array: SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { HashTable *ht = Z_ARRVAL_P(object_ptr); @@ -99385,8 +105056,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV } } } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); } else { variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); @@ -99414,200 +105085,43 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV zend_object *obj = Z_OBJ_P(object_ptr); GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { - dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { - dim++; - } - - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { - value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) { - ZVAL_DEREF(value); - } - - zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); - - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - if (UNEXPECTED(GC_DELREF(obj) == 0)) { - zend_objects_store_del(obj); - } - } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { - zend_use_new_element_for_string(); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - UNDEF_RESULT(); - } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); - zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - } - } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { - if (Z_ISREF_P(orig_object_ptr) - && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) - && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); - UNDEF_RESULT(); - } else { - HashTable *ht = zend_new_array(8); - uint8_t old_type = Z_TYPE_P(object_ptr); - - ZVAL_ARR(object_ptr, ht); - if (UNEXPECTED(old_type == IS_FALSE)) { - GC_ADDREF(ht); - zend_false_to_array_deprecated(); - if (UNEXPECTED(GC_DELREF(ht) == 0)) { - zend_array_destroy(ht); - goto assign_dim_error; - } - } - goto try_assign_dim_array; - } - } else { - zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); -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_UNUSED) { - zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); - } - - - /* assign_dim has two opcodes! */ - ZEND_VM_NEXT_OPCODE_EX(1, 2); -} - -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) -{ - USE_OPLINE - zval *object_ptr, *orig_object_ptr; - zval *value; - zval *variable_ptr; - zval *dim; - zend_refcounted *garbage = NULL; - - SAVE_OPLINE(); - orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); - - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { -try_assign_dim_array: - SEPARATE_ARRAY(object_ptr); - if (IS_TMP_VAR == IS_UNUSED) { - value = EX_VAR((opline+1)->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { - HashTable *ht = Z_ARRVAL_P(object_ptr); - if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { - GC_ADDREF(ht); - } - value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { - zend_array_destroy(ht); - goto assign_dim_error; - } - } - if (IS_CV == IS_CV || IS_CV == IS_VAR) { - ZVAL_DEREF(value); - } - value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); - if (UNEXPECTED(value == NULL)) { - zend_cannot_add_element(); - goto assign_dim_error; - } else if (IS_CV == IS_CV) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); - } - } else if (IS_CV == IS_VAR) { - zval *free_op_data = EX_VAR((opline+1)->op1.var); - if (Z_ISREF_P(free_op_data)) { - if (Z_REFCOUNTED_P(value)) { - Z_ADDREF_P(value); - } - zval_ptr_dtor_nogc(free_op_data); - } - } else if (IS_CV == IS_CONST) { - if (UNEXPECTED(Z_REFCOUNTED_P(value))) { - Z_ADDREF_P(value); - } - } - } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { - variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); - } else { - variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); - } - if (UNEXPECTED(variable_ptr == NULL)) { - goto assign_dim_error; - } - value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); - } - if (UNEXPECTED(RETURN_VALUE_USED(opline))) { - ZVAL_COPY(EX_VAR(opline->result.var), value); - } - if (garbage) { - GC_DTOR_NO_REF(garbage); - } - } else { - if (EXPECTED(Z_ISREF_P(object_ptr))) { - object_ptr = Z_REFVAL_P(object_ptr); - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { - goto try_assign_dim_array; - } - } - if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { - zend_object *obj = Z_OBJ_P(object_ptr); - - GC_ADDREF(obj); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { dim = ZVAL_UNDEFINED_OP2(); - } else if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { dim++; } - value = EX_VAR((opline+1)->op1.var); - if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); - } else if (IS_CV & (IS_CV|IS_VAR)) { + } else if (IS_TMP_VAR & (IS_CV|IS_VAR)) { ZVAL_DEREF(value); } zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); if (UNEXPECTED(GC_DELREF(obj) == 0)) { zend_objects_store_del(obj); } } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { - if (IS_TMP_VAR == IS_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { zend_use_new_element_for_string(); - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - value = EX_VAR((opline+1)->op1.var); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); - - + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); } } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { if (Z_ISREF_P(orig_object_ptr) && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - - + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); UNDEF_RESULT(); } else { HashTable *ht = zend_new_array(8); @@ -99626,16 +105140,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV } } else { zend_use_scalar_as_array(); - dim = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); 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_UNUSED) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -99644,67 +105157,319 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *object_ptr, *orig_object_ptr; zval *value; zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - variable_ptr = EX_VAR(opline->op1.var); - - if (0 || UNEXPECTED(0)) { - zend_refcounted *garbage = NULL; + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(0)) { + 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) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { GC_DTOR_NO_REF(garbage); } } else { - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); - } + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + GC_ADDREF(obj); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } - /* zend_assign_to_variable() always takes care of op2, never free it! */ + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); +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(EX_VAR(opline->op2.var)); + } + + + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE + zval *object_ptr, *orig_object_ptr; zval *value; zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; SAVE_OPLINE(); - value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - variable_ptr = EX_VAR(opline->op1.var); - - if (0 || UNEXPECTED(1)) { - zend_refcounted *garbage = NULL; + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); - value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); - if (UNEXPECTED(1)) { + 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) { + value = EX_VAR((opline+1)->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_CV == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_CV == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_CV == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_cv_BP_VAR_R((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { ZVAL_COPY(EX_VAR(opline->result.var), value); } if (garbage) { GC_DTOR_NO_REF(garbage); } } else { - value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); - } + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + GC_ADDREF(obj); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } - /* zend_assign_to_variable() always takes care of op2, never free it! */ + value = EX_VAR((opline+1)->op1.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_CV & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } - ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if ((IS_TMP_VAR|IS_VAR) == IS_UNUSED) { + zend_use_new_element_for_string(); + + + UNDEF_RESULT(); + } else { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + value = EX_VAR((opline+1)->op1.var); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + + + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + + + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); +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(EX_VAR(opline->op2.var)); + } + + + /* assign_dim has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -99712,26 +105477,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_CV == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_CV, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } @@ -99740,8 +105505,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *property, *container, *value_ptr; @@ -99749,26 +105514,26 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - property = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + property = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); value_ptr = _get_zval_ptr_cv_BP_VAR_W((opline+1)->op1.var EXECUTE_DATA_CC); if (1) { if (IS_CV == IS_UNUSED) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_this_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_this_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } else { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { zend_assign_to_property_reference_var_const(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } else { zend_assign_to_property_reference_var_var(container, property, value_ptr OPLINE_CC EXECUTE_DATA_CC); } } } else { - zend_assign_to_property_reference(container, IS_CV, property, IS_TMP_VAR, value_ptr OPLINE_CC EXECUTE_DATA_CC); + zend_assign_to_property_reference(container, IS_CV, property, (IS_TMP_VAR|IS_VAR), value_ptr OPLINE_CC EXECUTE_DATA_CC); } @@ -99778,8 +105543,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *op1, *op2; @@ -99787,16 +105552,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C op1 = EX_VAR(opline->op1.var); - op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if ((IS_CV == IS_CONST || EXPECTED(Z_TYPE_P(op1) == IS_STRING)) && - (IS_TMP_VAR == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { + ((IS_TMP_VAR|IS_VAR) == IS_CONST || EXPECTED(Z_TYPE_P(op2) == IS_STRING))) { zend_string *op1_str = Z_STR_P(op1); zend_string *op2_str = Z_STR_P(op2); zend_string *str; uint32_t flags = ZSTR_GET_COPYABLE_CONCAT_PROPERTIES_BOTH(op1_str, op2_str); if (IS_CV != IS_CONST && UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST || (IS_TMP_VAR|IS_VAR) == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op2_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op2_str); @@ -99804,13 +105569,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - } else if (IS_TMP_VAR != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { + } else if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CV == IS_CONST || IS_CV == IS_CV) { ZVAL_STR_COPY(EX_VAR(opline->result.var), op1_str); } else { ZVAL_STR(EX_VAR(opline->result.var), op1_str); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else if (IS_CV != IS_CONST && IS_CV != IS_CV && @@ -99821,7 +105586,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C memcpy(ZSTR_VAL(str) + len, ZSTR_VAL(op2_str), ZSTR_LEN(op2_str)+1); GC_ADD_FLAGS(str, flags); ZVAL_NEW_STR(EX_VAR(opline->result.var), str); - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } else { @@ -99833,7 +105598,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C if (IS_CV & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR & (IS_TMP_VAR|IS_VAR)) { + if ((IS_TMP_VAR|IS_VAR) & (IS_TMP_VAR|IS_VAR)) { zend_string_release_ex(op2_str, 0); } } @@ -99851,12 +105616,12 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C } op1_str = zval_get_string_func(op1); } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { op2_str = Z_STR_P(op2); } else if (EXPECTED(Z_TYPE_P(op2) == IS_STRING)) { op2_str = zend_string_copy(Z_STR_P(op2)); } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(op2) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); } op2_str = zval_get_string_func(op2); @@ -99864,7 +105629,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C do { if (IS_CV != IS_CONST) { if (UNEXPECTED(ZSTR_LEN(op1_str) == 0)) { - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(op2))) { GC_ADDREF(op2_str); } @@ -99874,7 +105639,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C break; } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (UNEXPECTED(ZSTR_LEN(op2_str) == 0)) { if (IS_CV == IS_CONST) { if (UNEXPECTED(Z_REFCOUNTED_P(op1))) { @@ -99895,7 +105660,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C if (IS_CV != IS_CONST) { zend_string_release_ex(op1_str, 0); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_string_release_ex(op2_str, 0); } } while (0); @@ -99905,7 +105670,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_C ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *function_name; @@ -99920,19 +105685,19 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S object = EX_VAR(opline->op1.var); - if (IS_TMP_VAR != IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } - if (IS_TMP_VAR != IS_CONST && + if ((IS_TMP_VAR|IS_VAR) != IS_CONST && UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) { do { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && Z_ISREF_P(function_name)) { function_name = Z_REFVAL_P(function_name); if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) { break; } - } else if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(function_name) == IS_UNDEF)) { ZVAL_UNDEFINED_OP2(); if (UNEXPECTED(EG(exception) != NULL)) { @@ -99974,14 +105739,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(object) == IS_UNDEF)) { object = ZVAL_UNDEFINED_OP1(); if (UNEXPECTED(EG(exception) != NULL)) { - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } HANDLE_EXCEPTION(); } } - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } zend_invalid_method_call(object, function_name); zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); @@ -99994,18 +105759,18 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S called_scope = obj->ce; - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(CACHED_PTR(opline->result.num) == called_scope)) { fbc = CACHED_PTR(opline->result.num + sizeof(void*)); } else { zend_object *orig_obj = obj; - if (IS_TMP_VAR == IS_CONST) { - function_name = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { + function_name = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); } /* First, locate the function. */ - fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); + fbc = obj->handlers->get_method(&obj, Z_STR_P(function_name), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? (RT_CONSTANT(opline, opline->op2) + 1) : NULL)); if (UNEXPECTED(fbc == NULL)) { if (EXPECTED(!EG(exception))) { zend_undefined_method(orig_obj->ce, Z_STR_P(function_name)); @@ -100016,7 +105781,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S } HANDLE_EXCEPTION(); } - if (IS_TMP_VAR == IS_CONST && + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && EXPECTED(!(fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_TRAMPOLINE|ZEND_ACC_NEVER_CACHE))) && EXPECTED(obj == orig_obj)) { CACHE_POLYMORPHIC_PTR(opline->result.num, called_scope, fbc); @@ -100032,7 +105797,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S } } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); } @@ -100063,7 +105828,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_METHOD_CALL_S ZEND_VM_NEXT_OPCODE(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *expr_ptr, new_expr; @@ -100104,15 +105869,15 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ } } - if (IS_TMP_VAR != IS_UNUSED) { - zval *offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); zend_string *str; zend_ulong hval; add_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index; } @@ -100123,7 +105888,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ hval = Z_LVAL_P(offset); num_index: zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto add_again; } else if (UNEXPECTED(Z_TYPE_P(offset) == IS_NULL)) { @@ -100156,7 +105921,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); str = ZSTR_EMPTY_ALLOC(); goto str_index; @@ -100174,7 +105939,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ADD_ARRAY_ELEMENT_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zval *array; uint32_t size; @@ -100189,14 +105954,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INIT_ARRAY_SPEC_CV if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) { zend_hash_real_init_mixed(Z_ARRVAL_P(array)); } - ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); + ZEND_VM_TAIL_CALL(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { ZVAL_ARR(array, zend_new_array(0)); ZEND_VM_NEXT_OPCODE(); } } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -100206,7 +105971,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_CV_ SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { @@ -100218,7 +105983,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_CV_ offset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { key = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(key, hval)) { goto num_index_dim; } @@ -100230,7 +105995,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_CV_ hval = Z_LVAL_P(offset); num_index_dim: zend_hash_index_del(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_TYPE_P(offset) == IS_REFERENCE)) { offset = Z_REFVAL_P(offset); goto offset_again; } else if (Z_TYPE_P(offset) == IS_DOUBLE) { @@ -100259,7 +106024,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_CV_ zend_use_resource_as_offset(offset); hval = Z_RES_HANDLE_P(offset); goto num_index_dim; - } else if (IS_TMP_VAR == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { + } else if ((IS_TMP_VAR|IS_VAR) == IS_CV && Z_TYPE_P(offset) == IS_UNDEF) { ZVAL_UNDEFINED_OP2(); key = ZSTR_EMPTY_ALLOC(); goto str_index_dim; @@ -100276,11 +106041,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_CV_ if (IS_CV == IS_CV && UNEXPECTED(Z_TYPE_P(container) == IS_UNDEF)) { container = ZVAL_UNDEFINED_OP1(); } - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(offset) == IS_UNDEF)) { offset = ZVAL_UNDEFINED_OP2(); } if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } Z_OBJ_HT_P(container)->unset_dimension(Z_OBJ_P(container), offset); @@ -100299,7 +106064,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_DIM_SPEC_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -100308,7 +106073,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_CV_ SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); do { if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT)) { @@ -100325,7 +106090,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_CV_ break; } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -100333,8 +106098,8 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_CV_ break; } } - Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + Z_OBJ_HT_P(container)->unset_property(Z_OBJ_P(container), name, (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL)); + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } } while (0); @@ -100345,7 +106110,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_OBJ_SPEC_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -100355,7 +106120,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { HashTable *ht; @@ -100367,17 +106132,17 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ isset_again: if (EXPECTED(Z_TYPE_P(offset) == IS_STRING)) { str = Z_STR_P(offset); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { if (ZEND_HANDLE_NUMERIC(str, hval)) { goto num_index_prop; } } - value = zend_hash_find_ex(ht, str, IS_TMP_VAR == IS_CONST); + value = zend_hash_find_ex(ht, str, (IS_TMP_VAR|IS_VAR) == IS_CONST); } else if (EXPECTED(Z_TYPE_P(offset) == IS_LONG)) { hval = Z_LVAL_P(offset); num_index_prop: value = zend_hash_index_find(ht, hval); - } else if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { + } else if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(offset))) { offset = Z_REFVAL_P(offset); goto isset_again; } else { @@ -100409,7 +106174,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ } } - if (IS_TMP_VAR == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST && Z_EXTRA_P(offset) == ZEND_EXTRA_VALUE) { offset++; } if (!(opline->extended_value & ZEND_ISEMPTY)) { @@ -100425,7 +106190,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_DIM_ ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE zval *container; @@ -100435,7 +106200,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC); - offset = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + offset = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -100451,7 +106216,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP } } - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(offset); } else { name = zval_try_get_tmp_string(offset, &tmp_name); @@ -100463,9 +106228,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP result = (opline->extended_value & ZEND_ISEMPTY) ^ - Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), ((IS_TMP_VAR == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); + Z_OBJ_HT_P(container)->has_property(Z_OBJ_P(container), name, (opline->extended_value & ZEND_ISEMPTY), (((IS_TMP_VAR|IS_VAR) == IS_CONST) ? CACHE_ADDR(opline->extended_value & ~ZEND_ISEMPTY) : NULL)); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -100476,7 +106241,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_PROP ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -100487,14 +106252,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_S SAVE_OPLINE(); key = EX_VAR(opline->op1.var); - subject = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + subject = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { array_key_exists_array: ht = Z_ARRVAL_P(subject); result = zend_array_key_exists_fast(ht, key OPLINE_CC EXECUTE_DATA_CC); } else { - if ((IS_TMP_VAR & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { + if (((IS_TMP_VAR|IS_VAR) & (IS_VAR|IS_CV)) && EXPECTED(Z_ISREF_P(subject))) { subject = Z_REFVAL_P(subject); if (EXPECTED(Z_TYPE_P(subject) == IS_ARRAY)) { goto array_key_exists_array; @@ -100510,7 +106275,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ARRAY_KEY_EXISTS_S ZEND_VM_SMART_BRANCH(result, 1); } -static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CV_TMPVAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -100597,9 +106362,9 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CV_TMP_ } /* Set the new yielded key */ - if (IS_TMP_VAR != IS_UNUSED) { - zval *key = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); - if ((IS_TMP_VAR & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { + if ((IS_TMP_VAR|IS_VAR) != IS_UNUSED) { + zval *key = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (((IS_TMP_VAR|IS_VAR) & (IS_CV|IS_VAR)) && UNEXPECTED(Z_TYPE_P(key) == IS_REFERENCE)) { key = Z_REFVAL_P(key); } ZVAL_COPY(&generator->key, key); @@ -100632,6 +106397,190 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_YIELD_SPEC_CV_TMP_ ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + + if (0 || UNEXPECTED(0)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + + + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_tmp(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + + if (0 || UNEXPECTED(1)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_TMP_VAR, EX_USES_STRICT_TYPES()); + } + + + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_IDENTICAL_SPEC_CV_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_identical_function(op1, op2); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *op1, *op2; + bool result; + + SAVE_OPLINE(); + op1 = _get_zval_ptr_cv_deref_BP_VAR_R(opline->op1.var EXECUTE_DATA_CC); + op2 = _get_zval_ptr_var_deref(opline->op2.var EXECUTE_DATA_CC); + result = fast_is_not_identical_function(op1, op2); + + + zval_ptr_dtor_nogc(EX_VAR(opline->op2.var)); + ZEND_VM_SMART_BRANCH(result, 1); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + + if (0 || UNEXPECTED(0)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(0)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + + + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *value; + zval *variable_ptr; + + SAVE_OPLINE(); + value = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + variable_ptr = EX_VAR(opline->op1.var); + + if (0 || UNEXPECTED(1)) { + zend_refcounted *garbage = NULL; + + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(1)) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + value = zend_assign_to_variable(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES()); + } + + + /* zend_assign_to_variable() always takes care of op2, never free it! */ + + ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_REF_SPEC_CV_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -100684,13 +106633,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_CV try_instanceof: if (Z_TYPE_P(expr) == IS_OBJECT) { zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; if (IS_VAR == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); + CACHE_PTR(cache_slot, ce); } } } else if (IS_VAR == IS_UNUSED) { @@ -100705,6 +106655,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_CV ce = Z_CE_P(EX_VAR(opline->op2.var)); } result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_VAR == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { expr = Z_REFVAL_P(expr); goto try_instanceof; @@ -100855,7 +106820,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_IS_SPEC_CV_U ZEND_VM_DISPATCH_TO_HELPER(zend_fetch_var_address_helper_SPEC_CV_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_EX BP_VAR_IS)); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -100903,12 +106868,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_UNUSED == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CV & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_NULL_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -101227,6 +107186,161 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_UNUSED == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = NULL; + if (IS_UNUSED == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = NULL; + if (IS_UNUSED == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_UNUSED == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_UNUSED == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = NULL; + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = NULL; + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_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); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -101857,7 +107971,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_UNSET_VAR_SPEC_CV_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -101946,7 +108060,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ISSET_ISEMPTY_VAR_ ZEND_VM_SMART_BRANCH(result, true); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_CV_UNUSED_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -101959,13 +108073,14 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_CV try_instanceof: if (Z_TYPE_P(expr) == IS_OBJECT) { zend_class_entry *ce; + uint32_t cache_slot = opline->extended_value & ~ZEND_INSTANCEOF_GENERIC_FLAG; if (IS_UNUSED == IS_CONST) { - ce = CACHED_PTR(opline->extended_value); + ce = CACHED_PTR(cache_slot); if (UNEXPECTED(ce == NULL)) { ce = zend_lookup_class_ex(Z_STR_P(RT_CONSTANT(opline, opline->op2)), Z_STR_P(RT_CONSTANT(opline, opline->op2) + 1), ZEND_FETCH_CLASS_NO_AUTOLOAD); if (EXPECTED(ce)) { - CACHE_PTR(opline->extended_value, ce); + CACHE_PTR(cache_slot, ce); } } } else if (IS_UNUSED == IS_UNUSED) { @@ -101980,6 +108095,21 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_INSTANCEOF_SPEC_CV ce = Z_CE_P(EX_VAR(opline->op2.var)); } result = ce && instanceof_function(Z_OBJCE_P(expr), ce); + + /* Check generic type arguments if present */ + if (result && IS_UNUSED == IS_CONST && (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG)) { + zend_generic_args *expected_args = (zend_generic_args *)(uintptr_t) + Z_LVAL_P(RT_CONSTANT(opline, opline->op2) + 2); + zend_generic_args *obj_args = Z_OBJ_P(expr)->generic_args; + if (expected_args && obj_args) { + const zend_generic_params_info *params_info = ce ? ce->generic_params_info : NULL; + result = zend_generic_args_compatible(expected_args, obj_args, params_info); + } else if (expected_args && !obj_args) { + /* Object has no generic args but we expect specific ones */ + result = 0; + } + /* If no expected_args, just check the base class (already done) */ + } } else if ((IS_CV & (IS_VAR|IS_CV)) && Z_TYPE_P(expr) == IS_REFERENCE) { expr = Z_REFVAL_P(expr); goto try_instanceof; @@ -102937,7 +109067,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_OP_SPEC ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMP|VAR|CV, UNUSED|CONST|TMPVAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -103211,17 +109341,13 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_R_SPEC_C SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } dim = EX_VAR(opline->op2.var); if (IS_CV != IS_CONST) { if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { fetch_dim_r_array: value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, IS_CV, BP_VAR_R EXECUTE_DATA_CC); ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); - } else if (IS_CV == IS_CV && EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { + } else if (EXPECTED(Z_TYPE_P(container) == IS_REFERENCE)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) { goto fetch_dim_r_array; @@ -103284,8 +109410,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_IS_SPEC_ SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - /* Unlike FETCH_DIM_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()['bar'] ??= baz. */ zend_fetch_dimension_address_read_IS(container, EX_VAR(opline->op2.var), IS_CV OPLINE_CC EXECUTE_DATA_CC); @@ -103309,12 +109433,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_DIM_FUNC_ARG if (IS_CV == IS_UNUSED) { ZEND_VM_TAIL_CALL(zend_use_undef_in_read_context_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } - if (IS_CV & IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_DIM_R_SPEC_CV_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -103343,15 +109461,11 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_R_SPEC_C SAVE_OPLINE(); container = EX_VAR(opline->op1.var); - if (IS_CV & (IS_VAR|IS_TMP_VAR)) { - /* Handler accepts VAR only for FUNC_ARG, which will unwrap before dispatching. */ - ZEND_ASSERT(Z_TYPE_P(container) != IS_REFERENCE); - } if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { do { - if ((IS_CV & IS_CV) && Z_ISREF_P(container)) { + if ((IS_CV & (IS_VAR|IS_CV)) && Z_ISREF_P(container)) { container = Z_REFVAL_P(container); if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) { break; @@ -103559,8 +109673,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_IS_SPEC_ SAVE_OPLINE(); container = _get_zval_ptr_cv_BP_VAR_IS(opline->op1.var EXECUTE_DATA_CC); - /* Unlike FETCH_OBJ_R, this may receive references through return-by-ref - * calls using ??=, i.e. foo()->bar ??= baz. */ if (IS_CV == IS_CONST || (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT))) { @@ -103689,12 +109801,6 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FETCH_OBJ_FUNC_ARG } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_W_SPEC_CV_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } else { - if (IS_CV == IS_VAR) { - zval *op1 = EX_VAR(opline->op1.var); - if (Z_TYPE_P(op1) == IS_REFERENCE) { - zend_unwrap_reference(op1); - } - } ZEND_VM_TAIL_CALL(ZEND_FETCH_OBJ_R_SPEC_CV_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU)); } } @@ -103755,7 +109861,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -103874,7 +109980,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -103913,7 +110019,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -104030,7 +110136,163 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *value, tmp; + zend_object *zobj; + zend_string *name, *tmp_name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = EX_VAR(opline->op1.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + + if (IS_CV != IS_UNUSED && UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) { + if (Z_ISREF_P(object) && Z_TYPE_P(Z_REFVAL_P(object)) == IS_OBJECT) { + object = Z_REFVAL_P(object); + goto assign_object; + } + zend_throw_non_object_error(object, _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC) OPLINE_CC EXECUTE_DATA_CC); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + +assign_object: + zobj = Z_OBJ_P(object); + if (IS_CV == IS_CONST) { + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + void **cache_slot = CACHE_ADDR(opline->extended_value); + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + zend_property_info *prop_info; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + +assign_obj_simple: + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + if (prop_info != NULL) { + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); + goto free_and_exit_assign_obj; + } else { +fast_assign_obj: + value = zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } + } else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(prop_offset))) { + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + if (UNEXPECTED(zend_lazy_object_must_init(zobj))) { + zobj = zend_lazy_object_init(zobj); + if (!zobj) { + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + } + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + rebuild_object_properties_internal(zobj); + } + if (EXPECTED(zobj->properties != NULL)) { + if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) { + if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) { + GC_DELREF(zobj->properties); + } + zobj->properties = zend_array_dup(zobj->properties); + } + property_val = zend_hash_find_known_hash(zobj->properties, name); + if (property_val) { + goto fast_assign_obj; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_VAR == IS_VAR) { + zend_reference *ref = Z_REF_P(value); + if (GC_DELREF(ref) == 0) { + ZVAL_COPY_VALUE(&tmp, Z_REFVAL_P(value)); + efree_size(ref, sizeof(zend_reference)); + value = &tmp; + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else { + value = Z_REFVAL_P(value); + Z_TRY_ADDREF_P(value); + } + } else if (IS_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + goto exit_assign_obj; + } + } else { + ZEND_ASSERT(IS_HOOKED_PROPERTY_OFFSET(prop_offset)); + if (ZEND_IS_PROPERTY_HOOK_SIMPLE_WRITE(prop_offset)) { + prop_info = CACHED_PTR_EX(cache_slot + 2); + prop_offset = prop_info->offset; + if (!ZEND_TYPE_IS_SET(prop_info->type)) { + prop_info = NULL; + } + goto assign_obj_simple; + } + /* Fall through to write_property for hooks. */ + } + } + name = Z_STR_P(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC)); + } else { + name = zval_try_get_tmp_string(_get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC), &tmp_name); + if (UNEXPECTED(!name)) { + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + goto exit_assign_obj; + } + } + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, (IS_CV == IS_CONST) ? CACHE_ADDR(opline->extended_value) : NULL); + + if (IS_CV != IS_CONST) { + zend_tmp_string_release(tmp_name); + } + +free_and_exit_assign_obj: + if (UNEXPECTED(RETURN_VALUE_USED(opline)) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), value); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); +exit_assign_obj: + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + + + + /* assign_obj has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -104069,7 +110331,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV property_val = OBJ_PROP(zobj, prop_offset); if (Z_TYPE_P(property_val) != IS_UNDEF) { if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage, zobj EXECUTE_DATA_CC); goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -104188,7 +110450,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -104503,6 +110765,161 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV ZEND_VM_NEXT_OPCODE_EX(1, 2); } +static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object_ptr, *orig_object_ptr; + zval *value; + zval *variable_ptr; + zval *dim; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + orig_object_ptr = object_ptr = EX_VAR(opline->op1.var); + + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { +try_assign_dim_array: + SEPARATE_ARRAY(object_ptr); + if (IS_CV == IS_UNUSED) { + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(value) == IS_UNDEF)) { + HashTable *ht = Z_ARRVAL_P(object_ptr); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE)) { + GC_ADDREF(ht); + } + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + if (!(GC_FLAGS(ht) & IS_ARRAY_IMMUTABLE) && !GC_DELREF(ht)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + value = zend_hash_next_index_insert(Z_ARRVAL_P(object_ptr), value); + if (UNEXPECTED(value == NULL)) { + zend_cannot_add_element(); + goto assign_dim_error; + } else if (IS_VAR == IS_CV) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + } else if (IS_VAR == IS_VAR) { + zval *free_op_data = EX_VAR((opline+1)->op1.var); + if (Z_ISREF_P(free_op_data)) { + if (Z_REFCOUNTED_P(value)) { + Z_ADDREF_P(value); + } + zval_ptr_dtor_nogc(free_op_data); + } + } else if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } + } else { + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CONST) { + variable_ptr = zend_fetch_dimension_address_inner_W_CONST(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } else { + variable_ptr = zend_fetch_dimension_address_inner_W(Z_ARRVAL_P(object_ptr), dim EXECUTE_DATA_CC); + } + if (UNEXPECTED(variable_ptr == NULL)) { + goto assign_dim_error; + } + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + value = zend_assign_to_variable_ex(variable_ptr, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + } + if (UNEXPECTED(RETURN_VALUE_USED(opline))) { + ZVAL_COPY(EX_VAR(opline->result.var), value); + } + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + } else { + if (EXPECTED(Z_ISREF_P(object_ptr))) { + object_ptr = Z_REFVAL_P(object_ptr); + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_ARRAY)) { + goto try_assign_dim_array; + } + } + if (EXPECTED(Z_TYPE_P(object_ptr) == IS_OBJECT)) { + zend_object *obj = Z_OBJ_P(object_ptr); + + GC_ADDREF(obj); + dim = EX_VAR(opline->op2.var); + if (IS_CV == IS_CV && UNEXPECTED(Z_ISUNDEF_P(dim))) { + dim = ZVAL_UNDEFINED_OP2(); + } else if (IS_CV == IS_CONST && Z_EXTRA_P(dim) == ZEND_EXTRA_VALUE) { + dim++; + } + + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + if (IS_VAR == IS_CV && UNEXPECTED(Z_ISUNDEF_P(value))) { + value = zval_undefined_cv((opline+1)->op1.var EXECUTE_DATA_CC); + } else if (IS_VAR & (IS_CV|IS_VAR)) { + ZVAL_DEREF(value); + } + + zend_assign_to_object_dim(obj, dim, value OPLINE_CC EXECUTE_DATA_CC); + + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (UNEXPECTED(GC_DELREF(obj) == 0)) { + zend_objects_store_del(obj); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) == IS_STRING)) { + if (IS_CV == IS_UNUSED) { + zend_use_new_element_for_string(); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + dim = EX_VAR(opline->op2.var); + value = _get_zval_ptr_var((opline+1)->op1.var EXECUTE_DATA_CC); + zend_assign_to_string_offset(object_ptr, dim, value OPLINE_CC EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + } + } else if (EXPECTED(Z_TYPE_P(object_ptr) <= IS_FALSE)) { + if (Z_ISREF_P(orig_object_ptr) + && ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(orig_object_ptr)) + && !zend_verify_ref_array_assignable(Z_REF_P(orig_object_ptr))) { + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + UNDEF_RESULT(); + } else { + HashTable *ht = zend_new_array(8); + uint8_t old_type = Z_TYPE_P(object_ptr); + + ZVAL_ARR(object_ptr, ht); + if (UNEXPECTED(old_type == IS_FALSE)) { + GC_ADDREF(ht); + zend_false_to_array_deprecated(); + if (UNEXPECTED(GC_DELREF(ht) == 0)) { + zend_array_destroy(ht); + goto assign_dim_error; + } + } + goto try_assign_dim_array; + } + } else { + zend_use_scalar_as_array(); + dim = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); +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); +} + static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -104799,7 +111216,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPEC_CV_CV_OP_DATA_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -104838,7 +111255,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_ASSIGN_OBJ_REF_SPE ZEND_VM_NEXT_OPCODE_EX(1, 2); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CONST|VAR) */ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_FAST_CONCAT_SPEC_CV_CV_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -105737,6 +112154,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_NULL_TAILCALL_HAND SAVE_OPLINE(); zend_error_noreturn(E_ERROR, "Invalid opcode %d/%d/%d.", OPLINE->opcode, OPLINE->op1_type, OPLINE->op2_type); + ZEND_VM_NEXT_OPCODE(); /* Never reached */ } static ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV ZEND_HALT_TAILCALL_HANDLER(ZEND_OPCODE_HANDLER_ARGS) @@ -106053,7 +112471,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_ &prop_info, opline->extended_value & ~ZEND_FETCH_OBJ_FLAGS, type, type == BP_VAR_W ? opline->extended_value : 0 OPLINE_CC EXECUTE_DATA_CC); if (UNEXPECTED(!prop)) { - ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS) || (type == BP_VAR_UNSET)); + ZEND_ASSERT(EG(exception) || (type == BP_VAR_IS)); prop = &EG(uninitialized_zval); } else if (UNEXPECTED(prop_info->flags & ZEND_ACC_PPP_SET_MASK) && (type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) @@ -106075,7 +112493,7 @@ static zend_always_inline ZEND_OPCODE_HANDLER_RET zend_fetch_static_prop_helper_ ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|TMP) */ +/* No specialization for op_types (CONST|TMPVAR|CV, UNUSED|CLASS_FETCH|CONST|VAR) */ static zend_never_inline ZEND_COLD ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX zend_cannot_pass_by_ref_helper_SPEC_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_EX uint32_t _arg_num, zval *_arg) { USE_OPLINE @@ -106299,7 +112717,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX z ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); } -static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX zend_fetch_var_address_helper_SPEC_TMP_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_EX int type) +static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX zend_fetch_var_address_helper_SPEC_TMPVAR_UNUSED_TAILCALL(ZEND_OPCODE_HANDLER_ARGS_EX int type) { USE_OPLINE zval *varname; @@ -106308,15 +112726,15 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX z HashTable *target_symbol_table; SAVE_OPLINE(); - varname = _get_zval_ptr_tmp(opline->op1.var EXECUTE_DATA_CC); + varname = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); - if (IS_TMP_VAR == IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) == IS_CONST) { name = Z_STR_P(varname); } else if (EXPECTED(Z_TYPE_P(varname) == IS_STRING)) { name = Z_STR_P(varname); tmp_name = NULL; } else { - if (IS_TMP_VAR == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV && UNEXPECTED(Z_TYPE_P(varname) == IS_UNDEF)) { ZVAL_UNDEFINED_OP1(); } name = zval_try_get_tmp_string(varname, &tmp_name); @@ -106330,12 +112748,12 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX z } target_symbol_table = zend_get_target_symbol_table(opline->extended_value EXECUTE_DATA_CC); - retval = zend_hash_find_ex(target_symbol_table, name, IS_TMP_VAR == IS_CONST); + retval = zend_hash_find_ex(target_symbol_table, name, (IS_TMP_VAR|IS_VAR) == IS_CONST); if (retval == NULL) { if (UNEXPECTED(zend_string_equals(name, ZSTR_KNOWN(ZEND_STR_THIS)))) { fetch_this: zend_fetch_this_var(type OPLINE_CC EXECUTE_DATA_CC); - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } ZEND_VM_NEXT_OPCODE_CHECK_EXCEPTION(); @@ -106345,7 +112763,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX z } else if (type == BP_VAR_IS || type == BP_VAR_UNSET) { retval = &EG(uninitialized_zval); } else { - if (IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { /* Keep name alive in case an error handler tries to free it. */ zend_string_addref(name); } @@ -106356,7 +112774,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX z } else { retval = &EG(uninitialized_zval); } - if (IS_TMP_VAR == IS_CV) { + if ((IS_TMP_VAR|IS_VAR) == IS_CV) { zend_string_release(name); } } @@ -106387,7 +112805,7 @@ static zend_never_inline ZEND_OPCODE_HANDLER_RET ZEND_OPCODE_HANDLER_CCONV_EX z zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); } - if (IS_TMP_VAR != IS_CONST) { + if ((IS_TMP_VAR|IS_VAR) != IS_CONST) { zend_tmp_string_release(tmp_name); } @@ -106628,28 +113046,28 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_LABEL, (void*)&&ZEND_DIV_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_DIV_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_DIV_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_DIV_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_DIV_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_DIV_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_DIV_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_DIV_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_DIV_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_DIV_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_DIV_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_DIV_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_DIV_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_DIV_SPEC_CV_CV_LABEL, (void*)&&ZEND_MOD_SPEC_CONST_CONST_LABEL, @@ -106728,28 +113146,28 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_SR_SPEC_TMPVARCV_TMPVARCV_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_CONCAT_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_CONCAT_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CONCAT_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_CONCAT_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_CONCAT_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_CONCAT_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CONCAT_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CONCAT_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_CONCAT_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_CONCAT_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CONCAT_SPEC_CV_CV_LABEL, (void*)&&ZEND_BW_OR_SPEC_CONST_CONST_LABEL, @@ -106828,28 +113246,28 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_LABEL, (void*)&&ZEND_POW_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_POW_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_POW_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POW_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_POW_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_POW_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_POW_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_POW_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_POW_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POW_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POW_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_POW_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_POW_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POW_SPEC_CV_CV_LABEL, (void*)&&ZEND_BW_NOT_SPEC_CONST_LABEL, @@ -106858,8 +113276,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_BW_NOT_SPEC_TMPVARCV_LABEL, (void*)&&ZEND_BOOL_NOT_SPEC_CONST_LABEL, - (void*)&&ZEND_BOOL_NOT_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_BOOL_NOT_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_BOOL_NOT_SPEC_CV_LABEL, (void*)&&ZEND_BOOL_XOR_SPEC_CONST_CONST_LABEL, @@ -106867,14 +113285,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_BOOL_XOR_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_BOOL_XOR_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -106883,8 +113301,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_BOOL_XOR_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_BOOL_XOR_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_BOOL_XOR_SPEC_CV_CV_LABEL, (void*)&&ZEND_IS_IDENTICAL_SPEC_CONST_CONST_LABEL, @@ -106897,9 +113315,9 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_TMP_LABEL, + (void*)&&ZEND_IS_IDENTICAL_SPEC_VAR_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -106909,7 +113327,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CONST_LABEL, (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_IS_IDENTICAL_SPEC_CV_CV_LABEL, (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_LABEL, @@ -106922,9 +113340,9 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_LABEL, + (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -106934,7 +113352,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_LABEL, (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_LABEL, (void*)&&ZEND_IS_EQUAL_SPEC_CONST_CONST_LABEL, @@ -106952,69 +113370,42 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_LABEL, - (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107024,15 +113415,24 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_LABEL, + (void*)&&ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107045,12 +113445,30 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107075,12 +113493,12 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_LABEL, (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_LABEL, (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ_LABEL, - (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_LABEL, + (void*)&&ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107261,8 +113679,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_LABEL, (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_LABEL, (void*)&&ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_LABEL, + (void*)&&ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_LABEL, @@ -107281,8 +113699,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_LABEL, (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_LABEL, (void*)&&ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_LABEL, + (void*)&&ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_LABEL, @@ -107339,27 +113757,27 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_LABEL, - (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST_LABEL, - (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107389,27 +113807,27 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_LABEL, - (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST_LABEL, - (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107464,19 +113882,19 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107484,24 +113902,24 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107509,24 +113927,24 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107534,12 +113952,12 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_LABEL, (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_LABEL, (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107553,8 +113971,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OP_SPEC_VAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107563,8 +113981,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OP_SPEC_CV_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107578,8 +113996,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107588,8 +114006,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107603,18 +114021,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_LABEL, (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_LABEL, (void*)&&ZEND_ASSIGN_STATIC_PROP_OP_SPEC_LABEL, @@ -107705,14 +114123,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107730,14 +114148,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107755,14 +114173,14 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -107808,30 +114226,30 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_POST_INC_STATIC_PROP_SPEC_LABEL, (void*)&&ZEND_JMP_SPEC_LABEL, (void*)&&ZEND_JMPZ_SPEC_CONST_LABEL, - (void*)&&ZEND_JMPZ_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_JMPZ_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMPZ_SPEC_CV_LABEL, (void*)&&ZEND_JMPNZ_SPEC_CONST_LABEL, - (void*)&&ZEND_JMPNZ_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_JMPNZ_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMPNZ_SPEC_CV_LABEL, (void*)&&ZEND_JMPZ_EX_SPEC_CONST_LABEL, - (void*)&&ZEND_JMPZ_EX_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_JMPZ_EX_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMPZ_EX_SPEC_CV_LABEL, (void*)&&ZEND_JMPNZ_EX_SPEC_CONST_LABEL, - (void*)&&ZEND_JMPNZ_EX_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_JMPNZ_EX_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMPNZ_EX_SPEC_CV_LABEL, - (void*)&&ZEND_CASE_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_CASE_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CASE_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_CASE_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_CASE_SPEC_TMP_CV_LABEL, + (void*)&&ZEND_CASE_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_CHECK_VAR_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL, (void*)&&ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_LABEL, @@ -107845,52 +114263,52 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CAST_SPEC_CONST_LABEL, (void*)&&ZEND_CAST_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CAST_SPEC_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CAST_SPEC_CV_LABEL, (void*)&&ZEND_BOOL_SPEC_CONST_LABEL, - (void*)&&ZEND_BOOL_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_BOOL_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_BOOL_SPEC_CV_LABEL, (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FAST_CONCAT_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_FAST_CONCAT_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_FAST_CONCAT_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_FAST_CONCAT_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FAST_CONCAT_SPEC_CV_CV_LABEL, (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ROPE_INIT_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL, + (void*)&&ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ROPE_ADD_SPEC_TMP_CV_LABEL, (void*)&&ZEND_ROPE_END_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_ROPE_END_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL, + (void*)&&ZEND_ROPE_END_SPEC_TMP_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ROPE_END_SPEC_TMP_CV_LABEL, (void*)&&ZEND_BEGIN_SILENCE_SPEC_LABEL, @@ -107905,8 +114323,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL, (void*)&&ZEND_RETURN_SPEC_TMP_LABEL, (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_RETURN_SPEC_VAR_LABEL, + (void*)&&ZEND_RETURN_SPEC_OBSERVER_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_RETURN_SPEC_CV_LABEL, @@ -108021,43 +114439,43 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_LABEL, (void*)&&ZEND_FREE_SPEC_TMPVAR_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CONST_CV_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_TMP_CV_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_VAR_CV_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_INIT_ARRAY_SPEC_CV_CV_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL, + (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108066,16 +114484,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_LABEL, (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CONST_LABEL, (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL, - (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMP_LABEL, + (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL, + (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_LABEL, (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INCLUDE_OR_EVAL_SPEC_CV_LABEL, @@ -108096,8 +114514,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_UNSET_DIM_SPEC_VAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108106,8 +114524,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_UNSET_DIM_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_UNSET_DIM_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_UNSET_DIM_SPEC_CV_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108121,44 +114539,44 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_UNSET_OBJ_SPEC_VAR_CV_LABEL, (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_UNSET_OBJ_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_UNSET_OBJ_SPEC_CV_CV_LABEL, (void*)&&ZEND_FE_RESET_R_SPEC_CONST_LABEL, (void*)&&ZEND_FE_RESET_R_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FE_RESET_R_SPEC_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FE_RESET_R_SPEC_CV_LABEL, - (void*)&&ZEND_FE_FETCH_R_SPEC_TMP_LABEL, + (void*)&&ZEND_FE_FETCH_R_SPEC_VAR_LABEL, (void*)&&ZEND_FETCH_R_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_FETCH_R_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_R_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_R_SPEC_CONST_CV_LABEL, (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108167,38 +114585,38 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_R_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_CONST_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_R_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_W_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_FETCH_W_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_W_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108212,8 +114630,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_W_SPEC_VAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108222,8 +114640,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_W_SPEC_CV_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108237,23 +114655,23 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_W_SPEC_VAR_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_W_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_RW_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_FETCH_RW_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_RW_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108267,8 +114685,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_RW_SPEC_VAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108277,8 +114695,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_RW_SPEC_CV_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108292,38 +114710,38 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_RW_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_IS_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_FETCH_IS_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_IS_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_IS_SPEC_CONST_CV_LABEL, (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108332,53 +114750,53 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_IS_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_IS_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108387,38 +114805,38 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_UNSET_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108432,8 +114850,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108442,8 +114860,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108457,33 +114875,33 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_CONST_CV_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL, - (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL, - (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108492,8 +114910,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_LABEL, - (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_LABEL, (void*)&&ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_LABEL, @@ -108519,18 +114937,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CATCH_SPEC_CONST_LABEL, (void*)&&ZEND_THROW_SPEC_CONST_LABEL, - (void*)&&ZEND_THROW_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_THROW_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_THROW_SPEC_CV_LABEL, (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_FETCH_CLASS_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_CLONE_SPEC_CONST_LABEL, - (void*)&&ZEND_CLONE_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_CLONE_SPEC_TMPVAR_LABEL, (void*)&&ZEND_CLONE_SPEC_UNUSED_LABEL, (void*)&&ZEND_CLONE_SPEC_CV_LABEL, (void*)&&ZEND_RETURN_BY_REF_SPEC_CONST_LABEL, @@ -108544,33 +114962,33 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_RETURN_BY_REF_SPEC_CV_LABEL, (void*)&&ZEND_RETURN_BY_REF_SPEC_OBSERVER_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_METHOD_CALL_SPEC_CV_CV_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108579,13 +114997,13 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108594,33 +115012,33 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_LABEL, (void*)&&ZEND_SEND_VAL_EX_SPEC_CONST_CONST_LABEL, @@ -108699,25 +115117,25 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_SEND_VAR_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_USER_CALL_SPEC_CONST_CV_LABEL, (void*)&&ZEND_SEND_ARRAY_SPEC_LABEL, (void*)&&ZEND_SEND_USER_SPEC_CONST_LABEL, (void*)&&ZEND_SEND_USER_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SEND_USER_SPEC_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_SEND_USER_SPEC_CV_LABEL, (void*)&&ZEND_STRLEN_SPEC_CONST_LABEL, - (void*)&&ZEND_STRLEN_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_STRLEN_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_STRLEN_SPEC_CV_LABEL, (void*)&&ZEND_DEFINED_SPEC_CONST_LABEL, (void*)&&ZEND_TYPE_CHECK_SPEC_CONST_LABEL, - (void*)&&ZEND_TYPE_CHECK_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_TYPE_CHECK_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_TYPE_CHECK_SPEC_CV_LABEL, (void*)&&ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_LABEL, @@ -108733,8 +115151,8 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_FE_FETCH_RW_SPEC_VAR_LABEL, (void*)&&ZEND_FE_FREE_SPEC_TMPVAR_LABEL, (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_LABEL, - (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_INIT_DYNAMIC_CALL_SPEC_CV_LABEL, (void*)&&ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_LABEL, @@ -108760,18 +115178,18 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_PRE_INC_OBJ_SPEC_VAR_CV_LABEL, (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_PRE_INC_OBJ_SPEC_CV_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108785,23 +115203,23 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_VAR_CV_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_POST_INC_OBJ_SPEC_CV_CV_LABEL, (void*)&&ZEND_ECHO_SPEC_CONST_LABEL, - (void*)&&ZEND_ECHO_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_ECHO_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ECHO_SPEC_CV_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108810,15 +115228,15 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_INSTANCEOF_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_INSTANCEOF_SPEC_TMP_VAR_LABEL, - (void*)&&ZEND_INSTANCEOF_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL, + (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_LABEL, + (void*)&&ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -108844,28 +115262,28 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_DECLARE_ANON_CLASS_SPEC_LABEL, (void*)&&ZEND_ADD_ARRAY_UNPACK_SPEC_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_LABEL, (void*)&&ZEND_HANDLE_EXCEPTION_SPEC_LABEL, @@ -108873,49 +115291,49 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_ASSERT_CHECK_SPEC_LABEL, (void*)&&ZEND_JMP_SET_SPEC_CONST_LABEL, (void*)&&ZEND_JMP_SET_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_JMP_SET_SPEC_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMP_SET_SPEC_CV_LABEL, (void*)&&ZEND_UNSET_CV_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_LABEL, (void*)&&ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_LABEL, (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_FETCH_LIST_W_SPEC_VAR_CV_LABEL, (void*)&&ZEND_SEPARATE_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_LABEL, (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_LABEL, (void*)&&ZEND_FETCH_CLASS_NAME_SPEC_CV_LABEL, (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_LABEL, (void*)&&ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_LABEL, (void*)&&ZEND_DISCARD_EXCEPTION_SPEC_LABEL, (void*)&&ZEND_YIELD_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_YIELD_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_YIELD_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_YIELD_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_YIELD_SPEC_CONST_CV_LABEL, (void*)&&ZEND_YIELD_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_YIELD_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL, + (void*)&&ZEND_YIELD_SPEC_TMP_TMPVAR_LABEL, (void*)&&ZEND_YIELD_SPEC_TMP_UNUSED_LABEL, (void*)&&ZEND_YIELD_SPEC_TMP_CV_LABEL, (void*)&&ZEND_YIELD_SPEC_VAR_CONST_LABEL, - (void*)&&ZEND_YIELD_SPEC_VAR_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL, + (void*)&&ZEND_YIELD_SPEC_VAR_TMPVAR_LABEL, (void*)&&ZEND_YIELD_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_YIELD_SPEC_VAR_CV_LABEL, (void*)&&ZEND_YIELD_SPEC_UNUSED_CONST_LABEL, - (void*)&&ZEND_YIELD_SPEC_UNUSED_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL, + (void*)&&ZEND_YIELD_SPEC_UNUSED_TMPVAR_LABEL, (void*)&&ZEND_YIELD_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_YIELD_SPEC_UNUSED_CV_LABEL, (void*)&&ZEND_YIELD_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_YIELD_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_YIELD_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_YIELD_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_YIELD_SPEC_CV_CV_LABEL, (void*)&&ZEND_GENERATOR_RETURN_SPEC_CONST_LABEL, @@ -108933,40 +115351,40 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_RECV_VARIADIC_SPEC_UNUSED_LABEL, (void*)&&ZEND_SEND_UNPACK_SPEC_LABEL, (void*)&&ZEND_YIELD_FROM_SPEC_CONST_LABEL, - (void*)&&ZEND_YIELD_FROM_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL, + (void*)&&ZEND_YIELD_FROM_SPEC_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_YIELD_FROM_SPEC_CV_LABEL, (void*)&&ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_BIND_GLOBAL_SPEC_CV_CONST_LABEL, (void*)&&ZEND_COALESCE_SPEC_CONST_LABEL, (void*)&&ZEND_COALESCE_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_COALESCE_SPEC_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_COALESCE_SPEC_CV_LABEL, (void*)&&ZEND_SPACESHIP_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_SPACESHIP_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_SPACESHIP_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_SPACESHIP_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_SPACESHIP_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_SPACESHIP_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_SPACESHIP_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_SPACESHIP_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_SPACESHIP_SPEC_CV_CV_LABEL, (void*)&&ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_LABEL, @@ -109029,48 +115447,48 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_LABEL, (void*)&&ZEND_IN_ARRAY_SPEC_CONST_CONST_LABEL, (void*)&&ZEND_IN_ARRAY_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_IN_ARRAY_SPEC_VAR_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_IN_ARRAY_SPEC_CV_CONST_LABEL, (void*)&&ZEND_COUNT_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_COUNT_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_COUNT_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_COUNT_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_GET_CLASS_SPEC_CONST_UNUSED_LABEL, - (void*)&&ZEND_GET_CLASS_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_GET_CLASS_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_LABEL, (void*)&&ZEND_GET_TYPE_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_GET_TYPE_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_GET_TYPE_SPEC_VAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_GET_TYPE_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_LABEL, - (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST_LABEL, - (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_LABEL, - (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL, + (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_LABEL, (void*)&&ZEND_MATCH_SPEC_CONST_CONST_LABEL, @@ -109078,11 +115496,31 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_MATCH_SPEC_TMPVARCV_CONST_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CONST_LABEL, (void*)&&ZEND_CASE_STRICT_SPEC_TMP_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_TMP_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_CASE_STRICT_SPEC_TMP_CV_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CONST_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_VAR_TMP_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_VAR_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CASE_STRICT_SPEC_VAR_CV_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL, (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL, @@ -109090,7 +115528,7 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_LABEL, (void*)&&ZEND_JMP_NULL_SPEC_CONST_LABEL, (void*)&&ZEND_JMP_NULL_SPEC_TMP_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_JMP_NULL_SPEC_VAR_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_JMP_NULL_SPEC_CV_LABEL, (void*)&&ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_LABEL, @@ -109109,12 +115547,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL, (void*)&&ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_LABEL, (void*)&&ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_LABEL, - (void*)&&ZEND_TYPE_ASSERT_SPEC_CONST_LABEL, (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, - (void*)&&ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED_LABEL, - (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL, + (void*)&&ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_LABEL, (void*)&&ZEND_NULL_LABEL, (void*)&&ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_LABEL, (void*)&&ZEND_JMP_FORWARD_SPEC_LABEL, @@ -110122,6 +116559,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR) + ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV) ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -110514,10 +116956,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_RECV_INIT_SPEC_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMP): - VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMP) - ZEND_INIT_DYNAMIC_CALL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMP) + HYBRID_CASE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR): + VM_TRACE(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) + ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR) HYBRID_BREAK(); HYBRID_CASE(ZEND_RECV_SPEC_UNUSED): VM_TRACE(ZEND_RECV_SPEC_UNUSED) @@ -110858,11 +117300,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_TYPE_CHECK_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_TYPE_ASSERT_SPEC_CONST): - VM_TRACE(ZEND_TYPE_ASSERT_SPEC_CONST) - ZEND_TYPE_ASSERT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_TYPE_ASSERT_SPEC_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_DEFINED_SPEC_CONST): VM_TRACE(ZEND_DEFINED_SPEC_CONST) ZEND_DEFINED_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -111268,110 +117705,110 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_DIV_SPEC_CONST_TMP): - VM_TRACE(ZEND_DIV_SPEC_CONST_TMP) - ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_POW_SPEC_CONST_TMP): - VM_TRACE(ZEND_POW_SPEC_CONST_TMP) - ZEND_POW_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_TMP): - VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMP) - ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMP): - VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMP) - ZEND_SPACESHIP_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMP): - VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMP) - ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMP): - VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMP) - ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP): - VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP) - ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMP): - VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMP) - ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP): - VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP) - ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP): - VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP) - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_TMP): - VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_TMP) - ZEND_FETCH_LIST_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_TMP): - VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_TMP) - ZEND_FAST_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP) - ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMP): - VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMP) - ZEND_INIT_USER_CALL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP): - VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP) - ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_TMP): - VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_TMP) - ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP): - VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP) - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP): - VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP) - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP): - VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP) - ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMP): - VM_TRACE(ZEND_YIELD_SPEC_CONST_TMP) - ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMP) + HYBRID_CASE(ZEND_DIV_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_DIV_SPEC_CONST_TMPVAR) + ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_DIV_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POW_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_POW_SPEC_CONST_TMPVAR) + ZEND_POW_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POW_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CONCAT_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_CONCAT_SPEC_CONST_TMPVAR) + ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_SPACESHIP_SPEC_CONST_TMPVAR) + ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) + ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) + ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) + ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) + ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) + ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) + ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) + ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) + ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) + ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) + ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) + ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_YIELD_SPEC_CONST_TMPVAR): + VM_TRACE(ZEND_YIELD_SPEC_CONST_TMPVAR) + ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_YIELD_SPEC_CONST_TMPVAR) HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_R_SPEC_CONST_UNUSED): VM_TRACE(ZEND_FETCH_R_SPEC_CONST_UNUSED) @@ -112148,10 +118585,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP): - VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP) - ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP) + HYBRID_CASE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR): + VM_TRACE(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR) HYBRID_BREAK(); HYBRID_CASE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED): VM_TRACE(ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED) @@ -112163,6 +118600,36 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMPVAR): + VM_TRACE(ZEND_BOOL_NOT_SPEC_TMPVAR) + ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ECHO_SPEC_TMPVAR): + VM_TRACE(ZEND_ECHO_SPEC_TMPVAR) + ZEND_ECHO_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ECHO_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_JMPZ_SPEC_TMPVAR): + VM_TRACE(ZEND_JMPZ_SPEC_TMPVAR) + ZEND_JMPZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_JMPZ_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_JMPNZ_SPEC_TMPVAR): + VM_TRACE(ZEND_JMPNZ_SPEC_TMPVAR) + ZEND_JMPNZ_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_JMPZ_EX_SPEC_TMPVAR): + VM_TRACE(ZEND_JMPZ_EX_SPEC_TMPVAR) + ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_TMPVAR): + VM_TRACE(ZEND_JMPNZ_EX_SPEC_TMPVAR) + ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_TMPVAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FREE_SPEC_TMPVAR): VM_TRACE(ZEND_FREE_SPEC_TMPVAR) ZEND_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112173,6 +118640,101 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FE_FREE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FE_FREE_SPEC_TMPVAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_THROW_SPEC_TMPVAR): + VM_TRACE(ZEND_THROW_SPEC_TMPVAR) + ZEND_THROW_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_THROW_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_BOOL_SPEC_TMPVAR): + VM_TRACE(ZEND_BOOL_SPEC_TMPVAR) + ZEND_BOOL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BOOL_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_SPEC_TMPVAR): + VM_TRACE(ZEND_CLONE_SPEC_TMPVAR) + ZEND_CLONE_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR): + VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) + ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMPVAR): + VM_TRACE(ZEND_YIELD_FROM_SPEC_TMPVAR) + ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_STRLEN_SPEC_TMPVAR): + VM_TRACE(ZEND_STRLEN_SPEC_TMPVAR) + ZEND_STRLEN_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMPVAR): + VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMPVAR) + ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR): + VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) + ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CONST) + ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_POW_SPEC_TMPVAR_CONST) + ZEND_POW_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CONST) + ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST) + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ): + VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ) + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ): + VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ) + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST) + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ) + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ) + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CONST) + ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST) + ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST): VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST) ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112193,11 +118755,46 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) + ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST): VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_CONST) ZEND_SEND_VAL_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_SPEC_TMPVAR_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CONST) + ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST): + VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) + ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST): VM_TRACE(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112208,25 +118805,145 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP): - VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP) - ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP): - VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP) - ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP): - VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP) - ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP): - VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP) - ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP) + HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_DIV_SPEC_TMPVAR_TMPVAR) + ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_POW_SPEC_TMPVAR_TMPVAR) + ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR) + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR) + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ): + VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ) + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ): + VM_TRACE(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ) + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR) + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ) + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ) + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR) + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_CASE_SPEC_TMPVAR_TMPVAR) + ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR): + VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR): + VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) + ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) + ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) + ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) + ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) + ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) + ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) + ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED) HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED): VM_TRACE(ZEND_SEND_VAL_SPEC_TMPVAR_UNUSED) @@ -112238,11 +118955,56 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_UNSET_VAR_SPEC_TMPVAR_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) + ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) + ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_COUNT_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_COUNT_SPEC_TMPVAR_UNUSED) + ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_COUNT_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) + ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED): + VM_TRACE(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) + ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED): VM_TRACE(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_DIV_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_DIV_SPEC_TMPVAR_CV) + ZEND_DIV_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_DIV_SPEC_TMPVAR_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POW_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_POW_SPEC_TMPVAR_CV) + ZEND_POW_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POW_SPEC_TMPVAR_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CONCAT_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_CONCAT_SPEC_TMPVAR_CV) + ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMPVAR_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_SPACESHIP_SPEC_TMPVAR_CV) + ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMPVAR_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV): VM_TRACE(ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV) ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112263,35 +119025,35 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_BOOL_NOT_SPEC_TMP): - VM_TRACE(ZEND_BOOL_NOT_SPEC_TMP) - ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BOOL_NOT_SPEC_TMP) + HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) + ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMPVAR_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_ECHO_SPEC_TMP): - VM_TRACE(ZEND_ECHO_SPEC_TMP) - ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ECHO_SPEC_TMP) + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_JMPZ_SPEC_TMP): - VM_TRACE(ZEND_JMPZ_SPEC_TMP) - ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_JMPZ_SPEC_TMP) + HYBRID_CASE(ZEND_CASE_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_CASE_SPEC_TMPVAR_CV) + ZEND_CASE_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CASE_SPEC_TMPVAR_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_JMPNZ_SPEC_TMP): - VM_TRACE(ZEND_JMPNZ_SPEC_TMP) - ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_JMPNZ_SPEC_TMP) + HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_JMPZ_EX_SPEC_TMP): - VM_TRACE(ZEND_JMPZ_EX_SPEC_TMP) - ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_JMPZ_EX_SPEC_TMP) + HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_JMPNZ_EX_SPEC_TMP): - VM_TRACE(ZEND_JMPNZ_EX_SPEC_TMP) - ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_JMPNZ_EX_SPEC_TMP) + HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV): + VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV) HYBRID_BREAK(); HYBRID_CASE(ZEND_RETURN_SPEC_TMP): VM_TRACE(ZEND_RETURN_SPEC_TMP) @@ -112387,36 +119149,16 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_GENERATOR_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_TMP) HYBRID_BREAK(); - HYBRID_CASE(ZEND_THROW_SPEC_TMP): - VM_TRACE(ZEND_THROW_SPEC_TMP) - ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_THROW_SPEC_TMP) - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_USER_SPEC_TMP): VM_TRACE(ZEND_SEND_USER_SPEC_TMP) ZEND_SEND_USER_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_TMP) HYBRID_BREAK(); - HYBRID_CASE(ZEND_BOOL_SPEC_TMP): - VM_TRACE(ZEND_BOOL_SPEC_TMP) - ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BOOL_SPEC_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CLONE_SPEC_TMP): - VM_TRACE(ZEND_CLONE_SPEC_TMP) - ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CLONE_SPEC_TMP) - HYBRID_BREAK(); HYBRID_CASE(ZEND_CAST_SPEC_TMP): VM_TRACE(ZEND_CAST_SPEC_TMP) ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_CAST_SPEC_TMP) HYBRID_BREAK(); - HYBRID_CASE(ZEND_INCLUDE_OR_EVAL_SPEC_TMP): - VM_TRACE(ZEND_INCLUDE_OR_EVAL_SPEC_TMP) - ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INCLUDE_OR_EVAL_SPEC_TMP) - HYBRID_BREAK(); HYBRID_CASE(ZEND_FE_RESET_R_SPEC_TMP): VM_TRACE(ZEND_FE_RESET_R_SPEC_TMP) ZEND_FE_RESET_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112427,11 +119169,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FE_RESET_RW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_TMP) HYBRID_BREAK(); - HYBRID_CASE(ZEND_FE_FETCH_R_SPEC_TMP): - VM_TRACE(ZEND_FE_FETCH_R_SPEC_TMP) - ZEND_FE_FETCH_R_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FE_FETCH_R_SPEC_TMP) - HYBRID_BREAK(); HYBRID_CASE(ZEND_END_SILENCE_SPEC_TMP): VM_TRACE(ZEND_END_SILENCE_SPEC_TMP) ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112457,41 +119194,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_QM_ASSIGN_SPEC_TMP) HYBRID_BREAK(); - HYBRID_CASE(ZEND_YIELD_FROM_SPEC_TMP): - VM_TRACE(ZEND_YIELD_FROM_SPEC_TMP) - ZEND_YIELD_FROM_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_YIELD_FROM_SPEC_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_STRLEN_SPEC_TMP): - VM_TRACE(ZEND_STRLEN_SPEC_TMP) - ZEND_STRLEN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_STRLEN_SPEC_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_TYPE_CHECK_SPEC_TMP): - VM_TRACE(ZEND_TYPE_CHECK_SPEC_TMP) - ZEND_TYPE_CHECK_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_TYPE_CHECK_SPEC_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_CLASS_NAME_SPEC_TMP): - VM_TRACE(ZEND_FETCH_CLASS_NAME_SPEC_TMP) - ZEND_FETCH_CLASS_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_CLASS_NAME_SPEC_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_DIV_SPEC_TMP_CONST): - VM_TRACE(ZEND_DIV_SPEC_TMP_CONST) - ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_DIV_SPEC_TMP_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_POW_SPEC_TMP_CONST): - VM_TRACE(ZEND_POW_SPEC_TMP_CONST) - ZEND_POW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_POW_SPEC_TMP_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CONCAT_SPEC_TMP_CONST): - VM_TRACE(ZEND_CONCAT_SPEC_TMP_CONST) - ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMP_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST): VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_CONST) ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112507,46 +119209,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMP_CONST): - VM_TRACE(ZEND_IS_EQUAL_SPEC_TMP_CONST) - ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMP_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ): - VM_TRACE(ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ) - ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ): - VM_TRACE(ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ) - ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST) - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ) - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ) - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMP_CONST): - VM_TRACE(ZEND_SPACESHIP_SPEC_TMP_CONST) - ZEND_SPACESHIP_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMP_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMP_CONST): - VM_TRACE(ZEND_BOOL_XOR_SPEC_TMP_CONST) - ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMP_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST): VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST) ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112557,11 +119219,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMP_CONST): - VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMP_CONST) - ZEND_FAST_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMP_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CONST): VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CONST) ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112572,21 +119229,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST) - ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST): VM_TRACE(ZEND_SEND_VAL_EX_SPEC_TMP_CONST) ZEND_SEND_VAL_EX_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAL_EX_SPEC_TMP_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_CASE_SPEC_TMP_CONST): - VM_TRACE(ZEND_CASE_SPEC_TMP_CONST) - ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CASE_SPEC_TMP_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST) ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112597,26 +119244,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST): - VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST) - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST): - VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST) - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST): - VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST) - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMP_CONST): - VM_TRACE(ZEND_INSTANCEOF_SPEC_TMP_CONST) - ZEND_INSTANCEOF_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMP_CONST) - HYBRID_BREAK(); HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CONST): VM_TRACE(ZEND_YIELD_SPEC_TMP_CONST) ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112627,20 +119254,40 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_TMP_CONST) HYBRID_BREAK(); - HYBRID_CASE(ZEND_DIV_SPEC_TMP_TMP): - VM_TRACE(ZEND_DIV_SPEC_TMP_TMP) - ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_DIV_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_POW_SPEC_TMP_TMP): - VM_TRACE(ZEND_POW_SPEC_TMP_TMP) - ZEND_POW_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_POW_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CONCAT_SPEC_TMP_TMP): - VM_TRACE(ZEND_CONCAT_SPEC_TMP_TMP) - ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMP_TMP) + HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR): + VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) + ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_TMPVAR): + VM_TRACE(ZEND_ROPE_END_SPEC_TMP_TMPVAR) + ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR): + VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) + ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR): + VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) + ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_YIELD_SPEC_TMP_TMPVAR): + VM_TRACE(ZEND_YIELD_SPEC_TMP_TMPVAR) + ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_TMPVAR) HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP): VM_TRACE(ZEND_IS_IDENTICAL_SPEC_TMP_TMP) @@ -112657,145 +119304,10 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP) HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMP_TMP): - VM_TRACE(ZEND_IS_EQUAL_SPEC_TMP_TMP) - ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ): - VM_TRACE(ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ) - ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ): - VM_TRACE(ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ) - ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP) - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ) - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ) - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMP_TMP): - VM_TRACE(ZEND_SPACESHIP_SPEC_TMP_TMP) - ZEND_SPACESHIP_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_BOOL_XOR_SPEC_TMP_TMP): - VM_TRACE(ZEND_BOOL_XOR_SPEC_TMP_TMP) - ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP): - VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP) - ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP): - VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP) - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMP_TMP): - VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMP_TMP) - ZEND_FAST_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_TMP): - VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_TMP) - ZEND_ROPE_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ROPE_ADD_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ROPE_END_SPEC_TMP_TMP): - VM_TRACE(ZEND_ROPE_END_SPEC_TMP_TMP) - ZEND_ROPE_END_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP) - ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CASE_SPEC_TMP_TMP): - VM_TRACE(ZEND_CASE_SPEC_TMP_TMP) - ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CASE_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP): - VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP) - ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_TMP_TMP): - VM_TRACE(ZEND_INIT_ARRAY_SPEC_TMP_TMP) - ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP): - VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP) - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP): - VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP) - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP): - VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP) - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_YIELD_SPEC_TMP_TMP): - VM_TRACE(ZEND_YIELD_SPEC_TMP_TMP) - ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMP_VAR): - VM_TRACE(ZEND_INSTANCEOF_SPEC_TMP_VAR) - ZEND_INSTANCEOF_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMP_VAR) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_R_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_FETCH_R_SPEC_TMP_UNUSED) - ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_R_SPEC_TMP_UNUSED) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_W_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_FETCH_W_SPEC_TMP_UNUSED) - ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_W_SPEC_TMP_UNUSED) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_RW_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_FETCH_RW_SPEC_TMP_UNUSED) - ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_RW_SPEC_TMP_UNUSED) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED) - ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_UNSET_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_FETCH_UNSET_SPEC_TMP_UNUSED) - ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_UNSET_SPEC_TMP_UNUSED) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_IS_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_FETCH_IS_SPEC_TMP_UNUSED) - ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_IS_SPEC_TMP_UNUSED) + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_VAR): + VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_VAR) + ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_VAR) HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED): VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED) @@ -112827,66 +119339,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_UNUSED) HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED) - ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INSTANCEOF_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_INSTANCEOF_SPEC_TMP_UNUSED) - ZEND_INSTANCEOF_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INSTANCEOF_SPEC_TMP_UNUSED) - HYBRID_BREAK(); HYBRID_CASE(ZEND_YIELD_SPEC_TMP_UNUSED): VM_TRACE(ZEND_YIELD_SPEC_TMP_UNUSED) ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_TMP_UNUSED) HYBRID_BREAK(); - HYBRID_CASE(ZEND_COUNT_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_COUNT_SPEC_TMP_UNUSED) - ZEND_COUNT_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_COUNT_SPEC_TMP_UNUSED) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) - ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_GET_CLASS_SPEC_TMP_UNUSED): - VM_TRACE(ZEND_GET_CLASS_SPEC_TMP_UNUSED) - ZEND_GET_CLASS_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_GET_CLASS_SPEC_TMP_UNUSED) - HYBRID_BREAK(); HYBRID_CASE(ZEND_GET_TYPE_SPEC_TMP_UNUSED): VM_TRACE(ZEND_GET_TYPE_SPEC_TMP_UNUSED) ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_TMP_UNUSED) HYBRID_BREAK(); - HYBRID_CASE(ZEND_DIV_SPEC_TMP_CV): - VM_TRACE(ZEND_DIV_SPEC_TMP_CV) - ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_DIV_SPEC_TMP_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_POW_SPEC_TMP_CV): - VM_TRACE(ZEND_POW_SPEC_TMP_CV) - ZEND_POW_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_POW_SPEC_TMP_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CONCAT_SPEC_TMP_CV): - VM_TRACE(ZEND_CONCAT_SPEC_TMP_CV) - ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CONCAT_SPEC_TMP_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_CASE_STRICT_SPEC_TMP_CV): VM_TRACE(ZEND_CASE_STRICT_SPEC_TMP_CV) ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_TMP_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_SPACESHIP_SPEC_TMP_CV): - VM_TRACE(ZEND_SPACESHIP_SPEC_TMP_CV) - ZEND_SPACESHIP_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_TMP_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV): VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV) ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112897,11 +119364,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_TMP_CV): - VM_TRACE(ZEND_FAST_CONCAT_SPEC_TMP_CV) - ZEND_FAST_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_TMP_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ROPE_ADD_SPEC_TMP_CV): VM_TRACE(ZEND_ROPE_ADD_SPEC_TMP_CV) ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112912,16 +119374,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ROPE_END_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ROPE_END_SPEC_TMP_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_TMP_CV): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_TMP_CV) - ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_TMP_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CASE_SPEC_TMP_CV): - VM_TRACE(ZEND_CASE_SPEC_TMP_CV) - ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CASE_SPEC_TMP_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV): VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV) ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112932,21 +119384,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_TMP_CV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV): - VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV) - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV): - VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV) - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV): - VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV) - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_YIELD_SPEC_TMP_CV): VM_TRACE(ZEND_YIELD_SPEC_TMP_CV) ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112987,6 +119424,90 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_POST_DEC_SPEC_VAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_RETURN_SPEC_VAR): + VM_TRACE(ZEND_RETURN_SPEC_VAR) +{ + USE_OPLINE + zval *retval_ptr; + zval *return_value; + + + retval_ptr = _get_zval_ptr_var(opline->op1.var EXECUTE_DATA_CC); + return_value = EX(return_value); + + + if (IS_VAR == IS_CV && UNEXPECTED(Z_TYPE_INFO_P(retval_ptr) == IS_UNDEF)) { + SAVE_OPLINE(); + retval_ptr = ZVAL_UNDEFINED_OP1(); + if (return_value) { + ZVAL_NULL(return_value); + } + } else if (!return_value) { + if (IS_VAR & (IS_VAR|IS_TMP_VAR)) { + if (Z_REFCOUNTED_P(retval_ptr) && !Z_DELREF_P(retval_ptr)) { + SAVE_OPLINE(); + rc_dtor_func(Z_COUNTED_P(retval_ptr)); + } + } + } else { + if ((IS_VAR & (IS_CONST|IS_TMP_VAR))) { + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (IS_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(return_value))) { + Z_ADDREF_P(return_value); + } + } + } else if (IS_VAR == IS_CV) { + do { + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + if (EXPECTED(!Z_OPT_ISREF_P(retval_ptr))) { + if (EXPECTED(!(EX_CALL_INFO() & (ZEND_CALL_CODE|ZEND_CALL_OBSERVED)))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (GC_MAY_LEAK(ref)) { + SAVE_OPLINE(); + gc_possible_root(ref); + } + ZVAL_NULL(retval_ptr); + break; + } else { + Z_ADDREF_P(retval_ptr); + } + } else { + retval_ptr = Z_REFVAL_P(retval_ptr); + if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } + } + ZVAL_COPY_VALUE(return_value, retval_ptr); + } while (0); + } else /* if (IS_VAR == IS_VAR) */ { + if (UNEXPECTED(Z_ISREF_P(retval_ptr))) { + zend_refcounted *ref = Z_COUNTED_P(retval_ptr); + + retval_ptr = Z_REFVAL_P(retval_ptr); + ZVAL_COPY_VALUE(return_value, retval_ptr); + if (UNEXPECTED(GC_DELREF(ref) == 0)) { + efree_size(ref, sizeof(zend_reference)); + } else if (Z_OPT_REFCOUNTED_P(retval_ptr)) { + Z_ADDREF_P(retval_ptr); + } + } else { + ZVAL_COPY_VALUE(return_value, retval_ptr); + } + } + } + + + + + + + goto zend_leave_helper_SPEC_LABEL; +} + + VM_TRACE_OP_END(ZEND_RETURN_SPEC_VAR) HYBRID_CASE(ZEND_RETURN_BY_REF_SPEC_VAR): VM_TRACE(ZEND_RETURN_BY_REF_SPEC_VAR) ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -112997,16 +119518,51 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_GENERATOR_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_GENERATOR_RETURN_SPEC_VAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_SEND_USER_SPEC_VAR): + VM_TRACE(ZEND_SEND_USER_SPEC_VAR) + ZEND_SEND_USER_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SEND_USER_SPEC_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CAST_SPEC_VAR): + VM_TRACE(ZEND_CAST_SPEC_VAR) + ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CAST_SPEC_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FE_RESET_R_SPEC_VAR): + VM_TRACE(ZEND_FE_RESET_R_SPEC_VAR) + ZEND_FE_RESET_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FE_RESET_R_SPEC_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FE_RESET_RW_SPEC_VAR): VM_TRACE(ZEND_FE_RESET_RW_SPEC_VAR) ZEND_FE_RESET_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FE_RESET_RW_SPEC_VAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_FE_FETCH_R_SPEC_VAR): + VM_TRACE(ZEND_FE_FETCH_R_SPEC_VAR) + ZEND_FE_FETCH_R_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FE_FETCH_R_SPEC_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FE_FETCH_RW_SPEC_VAR): VM_TRACE(ZEND_FE_FETCH_RW_SPEC_VAR) ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FE_FETCH_RW_SPEC_VAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_JMP_SET_SPEC_VAR): + VM_TRACE(ZEND_JMP_SET_SPEC_VAR) + ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_JMP_SET_SPEC_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_COALESCE_SPEC_VAR): + VM_TRACE(ZEND_COALESCE_SPEC_VAR) + ZEND_COALESCE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_COALESCE_SPEC_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_JMP_NULL_SPEC_VAR): + VM_TRACE(ZEND_JMP_NULL_SPEC_VAR) + ZEND_JMP_NULL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_JMP_NULL_SPEC_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_QM_ASSIGN_SPEC_VAR): VM_TRACE(ZEND_QM_ASSIGN_SPEC_VAR) ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113017,6 +119573,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_SEND_VAR_SIMPLE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAR_SIMPLE_SPEC_VAR) HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST): + VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_CONST) + ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CONST): + VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CONST) + ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST): + VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST) + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST): VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST) ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113097,6 +119668,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV) ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113112,6 +119688,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) + ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV) ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113202,110 +119783,180 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CONST) HYBRID_BREAK(); + HYBRID_CASE(ZEND_IN_ARRAY_SPEC_VAR_CONST): + VM_TRACE(ZEND_IN_ARRAY_SPEC_VAR_CONST) + ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IN_ARRAY_SPEC_VAR_CONST) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV): VM_TRACE(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP): - VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP) - ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP): - VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP) - ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_TMP): - VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_TMP) - ZEND_ASSIGN_OP_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMP): - VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMP) - ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMP): - VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMP) - ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMP) - ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMP) - ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP) - ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP) - ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMP) - ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP) - ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP) - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP) - ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_TMP): - VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_TMP) - ZEND_FETCH_LIST_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST) - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP) - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV) - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST): - VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST) - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP): - VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP) - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV): - VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV) - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV) + HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR) + ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR) + ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR) + ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) + ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) + ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) + ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) + ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) + ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) + ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) + ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) + ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) + ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) + ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST) + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP) + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV) + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) + ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) + ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) + ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) + ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_YIELD_SPEC_VAR_TMPVAR): + VM_TRACE(ZEND_YIELD_SPEC_VAR_TMPVAR) + ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP): + VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_TMP) + ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_TMP): + VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_TMP) + ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP): + VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP) + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP) HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED): VM_TRACE(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED) @@ -113317,45 +119968,30 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED) HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR): - VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR) - ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV): - VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV) - ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP): - VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP) - ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_VAR_TMP): - VM_TRACE(ZEND_INIT_ARRAY_SPEC_VAR_TMP) - ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_UNSET_DIM_SPEC_VAR_TMP): - VM_TRACE(ZEND_UNSET_DIM_SPEC_VAR_TMP) - ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_VAR_TMP): - VM_TRACE(ZEND_UNSET_OBJ_SPEC_VAR_TMP) - ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_VAR_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_YIELD_SPEC_VAR_TMP): - VM_TRACE(ZEND_YIELD_SPEC_VAR_TMP) - ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_TMP) + HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR): + VM_TRACE(ZEND_IS_IDENTICAL_SPEC_VAR_VAR) + ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_VAR_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_VAR): + VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_VAR) + ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR): + VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR) + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED): + VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED) + ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED): + VM_TRACE(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED) + ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED) HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_VAR_VAR): VM_TRACE(ZEND_ASSIGN_REF_SPEC_VAR_VAR) @@ -113392,6 +120028,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) + ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV) ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113477,11 +120118,21 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_MAKE_REF_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_MAKE_REF_SPEC_VAR_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_GET_TYPE_SPEC_VAR_UNUSED): + VM_TRACE(ZEND_GET_TYPE_SPEC_VAR_UNUSED) + ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_GET_TYPE_SPEC_VAR_UNUSED) + HYBRID_BREAK(); HYBRID_CASE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED): VM_TRACE(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) HYBRID_BREAK(); + HYBRID_CASE(ZEND_CASE_STRICT_SPEC_VAR_CV): + VM_TRACE(ZEND_CASE_STRICT_SPEC_VAR_CV) + ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CASE_STRICT_SPEC_VAR_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV): VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV) ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113562,6 +120213,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV) ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113577,6 +120233,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) + ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV) ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113712,6 +120373,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV) ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -113787,115 +120453,120 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_CLASS_CONSTANT_SPEC_UNUSED_TMPVARCV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP) - ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP) - ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP) - ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP) - ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP) - ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP) - ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP) - ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP) - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP) - ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST) - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP) - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV) - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR): - VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR) - ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV): - VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV) - ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMP) - ZEND_ROPE_INIT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMP) - ZEND_FETCH_CLASS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP) - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP) - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMP) - ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMP) - ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP) - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_TMP): - VM_TRACE(ZEND_YIELD_SPEC_UNUSED_TMP) - ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_TMP) + HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR) + ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) + ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) + ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) + ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) + ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) + ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) + ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) + ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST) + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP) + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV) + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) + ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) + ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) + ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) + ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_YIELD_SPEC_UNUSED_TMPVAR): + VM_TRACE(ZEND_YIELD_SPEC_UNUSED_TMPVAR) + ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_YIELD_SPEC_UNUSED_TMPVAR) HYBRID_BREAK(); HYBRID_CASE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED): VM_TRACE(ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED) @@ -114052,6 +120723,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV) ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -114576,6 +121252,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV) ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -114591,6 +121272,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) + ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV) ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -114716,20 +121402,245 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) HYBRID_BREAK(); - HYBRID_CASE(ZEND_DIV_SPEC_CV_TMP): - VM_TRACE(ZEND_DIV_SPEC_CV_TMP) - ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_POW_SPEC_CV_TMP): - VM_TRACE(ZEND_POW_SPEC_CV_TMP) - ZEND_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_POW_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_CONCAT_SPEC_CV_TMP): - VM_TRACE(ZEND_CONCAT_SPEC_CV_TMP) - ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_TMP) + HYBRID_CASE(ZEND_DIV_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_DIV_SPEC_CV_TMPVAR) + ZEND_DIV_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_DIV_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POW_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_POW_SPEC_CV_TMPVAR) + ZEND_POW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POW_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CONCAT_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_CONCAT_SPEC_CV_TMPVAR) + ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CONCAT_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR) + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ): + VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ) + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ): + VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ) + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR) + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ) + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ): + VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ) + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMPVAR) + ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_TMPVAR) + ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR) + ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR) + ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR) + ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) + ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) + ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) + ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) + ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) + ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) + ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) + ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) + ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) + ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) + ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) + ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) + ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST) + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP) + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV) + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) + ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) + ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) + ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) + ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_TMPVAR) + ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) + ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) + ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_YIELD_SPEC_CV_TMPVAR): + VM_TRACE(ZEND_YIELD_SPEC_CV_TMPVAR) + ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMPVAR) HYBRID_BREAK(); HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_TMP): VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_TMP) @@ -114741,161 +121652,6 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP) HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMP): - VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMP) - ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ): - VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ) - ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ): - VM_TRACE(ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ) - ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP) - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ) - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ): - VM_TRACE(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ) - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_SPACESHIP_SPEC_CV_TMP): - VM_TRACE(ZEND_SPACESHIP_SPEC_CV_TMP) - ZEND_SPACESHIP_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_SPACESHIP_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_BOOL_XOR_SPEC_CV_TMP): - VM_TRACE(ZEND_BOOL_XOR_SPEC_CV_TMP) - ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_BOOL_XOR_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP): - VM_TRACE(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP) - ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP): - VM_TRACE(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP) - ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OP_SPEC_CV_TMP): - VM_TRACE(ZEND_ASSIGN_OP_SPEC_CV_TMP) - ZEND_ASSIGN_OP_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OP_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_PRE_INC_OBJ_SPEC_CV_TMP): - VM_TRACE(ZEND_PRE_INC_OBJ_SPEC_CV_TMP) - ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_PRE_INC_OBJ_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_POST_INC_OBJ_SPEC_CV_TMP): - VM_TRACE(ZEND_POST_INC_OBJ_SPEC_CV_TMP) - ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_POST_INC_OBJ_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_R_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_DIM_R_SPEC_CV_TMP) - ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_R_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_W_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_DIM_W_SPEC_CV_TMP) - ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_W_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_RW_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_DIM_RW_SPEC_CV_TMP) - ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_RW_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_IS_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_DIM_IS_SPEC_CV_TMP) - ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_IS_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP) - ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP) - ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_R_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_OBJ_R_SPEC_CV_TMP) - ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_R_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_W_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_OBJ_W_SPEC_CV_TMP) - ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_W_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_OBJ_RW_SPEC_CV_TMP) - ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_RW_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_OBJ_IS_SPEC_CV_TMP) - ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_IS_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP) - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP): - VM_TRACE(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP) - ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST) - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP) - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV): - VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV) - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST): - VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST) - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP): - VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP) - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV): - VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV) - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV) - HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED): VM_TRACE(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED) ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -114906,65 +121662,25 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED) HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR): - VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR) - ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV): - VM_TRACE(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV) - ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_FAST_CONCAT_SPEC_CV_TMP): - VM_TRACE(ZEND_FAST_CONCAT_SPEC_CV_TMP) - ZEND_FAST_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_FAST_CONCAT_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMP): - VM_TRACE(ZEND_INIT_METHOD_CALL_SPEC_CV_TMP) - ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_METHOD_CALL_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP): - VM_TRACE(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP) - ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_INIT_ARRAY_SPEC_CV_TMP): - VM_TRACE(ZEND_INIT_ARRAY_SPEC_CV_TMP) - ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_INIT_ARRAY_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_UNSET_DIM_SPEC_CV_TMP): - VM_TRACE(ZEND_UNSET_DIM_SPEC_CV_TMP) - ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_UNSET_DIM_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_UNSET_OBJ_SPEC_CV_TMP): - VM_TRACE(ZEND_UNSET_OBJ_SPEC_CV_TMP) - ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_UNSET_OBJ_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP): - VM_TRACE(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP) - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP): - VM_TRACE(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP) - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP): - VM_TRACE(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP) - ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP) - HYBRID_BREAK(); - HYBRID_CASE(ZEND_YIELD_SPEC_CV_TMP): - VM_TRACE(ZEND_YIELD_SPEC_CV_TMP) - ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); - VM_TRACE_OP_END(ZEND_YIELD_SPEC_CV_TMP) + HYBRID_CASE(ZEND_IS_IDENTICAL_SPEC_CV_VAR): + VM_TRACE(ZEND_IS_IDENTICAL_SPEC_CV_VAR) + ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_IDENTICAL_SPEC_CV_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR): + VM_TRACE(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR) + ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED): + VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED) + ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED): + VM_TRACE(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED) + ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED) HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_REF_SPEC_CV_VAR): VM_TRACE(ZEND_ASSIGN_REF_SPEC_CV_VAR) @@ -115036,6 +121752,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) + ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV) ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115306,6 +122027,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR) + ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV) ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115321,6 +122047,11 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP) HYBRID_BREAK(); + HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR): + VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) + ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR) + HYBRID_BREAK(); HYBRID_CASE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV): VM_TRACE(ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV) ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -115566,28 +122297,28 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_HANDLER, ZEND_DIV_SPEC_CONST_CONST_HANDLER, - ZEND_DIV_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER, + ZEND_DIV_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_DIV_SPEC_CONST_CV_HANDLER, - ZEND_DIV_SPEC_TMP_CONST_HANDLER, - ZEND_DIV_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_DIV_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER, + ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_CV_HANDLER, + ZEND_DIV_SPEC_TMPVAR_CONST_HANDLER, + ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_DIV_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_DIV_SPEC_CV_CONST_HANDLER, - ZEND_DIV_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_DIV_SPEC_CV_TMPVAR_HANDLER, + ZEND_DIV_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_DIV_SPEC_CV_CV_HANDLER, ZEND_MOD_SPEC_CONST_CONST_HANDLER, @@ -115666,28 +122397,28 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_SR_SPEC_TMPVARCV_TMPVARCV_HANDLER, ZEND_NULL_HANDLER, - ZEND_CONCAT_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER, + ZEND_CONCAT_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_CONCAT_SPEC_CONST_CV_HANDLER, - ZEND_CONCAT_SPEC_TMP_CONST_HANDLER, - ZEND_CONCAT_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_CONCAT_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_CONST_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_CONCAT_SPEC_CV_CONST_HANDLER, - ZEND_CONCAT_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER, + ZEND_CONCAT_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_CONCAT_SPEC_CV_CV_HANDLER, ZEND_BW_OR_SPEC_CONST_CONST_HANDLER, @@ -115766,28 +122497,28 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_HANDLER, ZEND_POW_SPEC_CONST_CONST_HANDLER, - ZEND_POW_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_POW_SPEC_CONST_TMPVAR_HANDLER, + ZEND_POW_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_POW_SPEC_CONST_CV_HANDLER, - ZEND_POW_SPEC_TMP_CONST_HANDLER, - ZEND_POW_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_POW_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_POW_SPEC_TMPVAR_CONST_HANDLER, + ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_POW_SPEC_TMPVAR_CV_HANDLER, + ZEND_POW_SPEC_TMPVAR_CONST_HANDLER, + ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_POW_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_POW_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_POW_SPEC_CV_CONST_HANDLER, - ZEND_POW_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_POW_SPEC_CV_TMPVAR_HANDLER, + ZEND_POW_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_POW_SPEC_CV_CV_HANDLER, ZEND_BW_NOT_SPEC_CONST_HANDLER, @@ -115796,8 +122527,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_BW_NOT_SPEC_TMPVARCV_HANDLER, ZEND_BOOL_NOT_SPEC_CONST_HANDLER, - ZEND_BOOL_NOT_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER, + ZEND_BOOL_NOT_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_BOOL_NOT_SPEC_CV_HANDLER, ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER, @@ -115805,14 +122536,14 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER, - ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -115821,8 +122552,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER, - ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER, + ZEND_BOOL_XOR_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER, ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER, @@ -115835,9 +122566,9 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER, + ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER, + ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -115847,7 +122578,7 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER, ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER, ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER, @@ -115860,9 +122591,9 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER, + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER, + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -115872,7 +122603,7 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER, ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER, ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER, @@ -115890,30 +122621,30 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -115938,12 +122669,12 @@ void zend_vm_init(void) ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER, ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER, ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -115965,30 +122696,30 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -116013,12 +122744,12 @@ void zend_vm_init(void) ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER, ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_HANDLER, ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -116199,8 +122930,8 @@ void zend_vm_init(void) ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_HANDLER, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_HANDLER, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_HANDLER, + ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER, @@ -116219,8 +122950,8 @@ void zend_vm_init(void) ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_HANDLER, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_HANDLER, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_HANDLER, + ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_HANDLER, @@ -116277,27 +123008,27 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_HANDLER, - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST_HANDLER, - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, @@ -116327,27 +123058,27 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_HANDLER, - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST_HANDLER, - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, @@ -116402,19 +123133,19 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -116422,24 +123153,24 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -116447,24 +123178,24 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -116472,12 +123203,12 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_HANDLER, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_HANDLER, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, @@ -116491,8 +123222,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OP_SPEC_VAR_CONST_HANDLER, - ZEND_ASSIGN_OP_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER, + ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OP_SPEC_VAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -116501,8 +123232,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OP_SPEC_CV_CONST_HANDLER, - ZEND_ASSIGN_OP_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER, + ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OP_SPEC_CV_CV_HANDLER, ZEND_NULL_HANDLER, @@ -116516,8 +123247,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_HANDLER, - ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER, + ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -116526,8 +123257,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_HANDLER, - ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER, + ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_HANDLER, ZEND_NULL_HANDLER, @@ -116541,18 +123272,18 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_HANDLER, - ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_HANDLER, - ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_HANDLER, - ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_HANDLER, ZEND_ASSIGN_STATIC_PROP_OP_SPEC_HANDLER, @@ -116643,14 +123374,14 @@ void zend_vm_init(void) ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -116668,14 +123399,14 @@ void zend_vm_init(void) ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -116693,14 +123424,14 @@ void zend_vm_init(void) ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -116746,30 +123477,30 @@ void zend_vm_init(void) ZEND_POST_INC_STATIC_PROP_SPEC_HANDLER, ZEND_JMP_SPEC_HANDLER, ZEND_JMPZ_SPEC_CONST_HANDLER, - ZEND_JMPZ_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_JMPZ_SPEC_TMPVAR_HANDLER, + ZEND_JMPZ_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_JMPZ_SPEC_CV_HANDLER, ZEND_JMPNZ_SPEC_CONST_HANDLER, - ZEND_JMPNZ_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_JMPNZ_SPEC_TMPVAR_HANDLER, + ZEND_JMPNZ_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_JMPNZ_SPEC_CV_HANDLER, ZEND_JMPZ_EX_SPEC_CONST_HANDLER, - ZEND_JMPZ_EX_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER, + ZEND_JMPZ_EX_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_JMPZ_EX_SPEC_CV_HANDLER, ZEND_JMPNZ_EX_SPEC_CONST_HANDLER, - ZEND_JMPNZ_EX_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER, + ZEND_JMPNZ_EX_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_JMPNZ_EX_SPEC_CV_HANDLER, - ZEND_CASE_SPEC_TMP_CONST_HANDLER, - ZEND_CASE_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_CASE_SPEC_TMPVAR_CONST_HANDLER, + ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_CASE_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, - ZEND_CASE_SPEC_TMP_CV_HANDLER, + ZEND_CASE_SPEC_TMPVAR_CV_HANDLER, ZEND_CHECK_VAR_SPEC_CV_UNUSED_HANDLER, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_HANDLER, @@ -116783,52 +123514,52 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_CAST_SPEC_CONST_HANDLER, ZEND_CAST_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_CAST_SPEC_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_CAST_SPEC_CV_HANDLER, ZEND_BOOL_SPEC_CONST_HANDLER, - ZEND_BOOL_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_BOOL_SPEC_TMPVAR_HANDLER, + ZEND_BOOL_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_BOOL_SPEC_CV_HANDLER, ZEND_FAST_CONCAT_SPEC_CONST_CONST_HANDLER, - ZEND_FAST_CONCAT_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER, + ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FAST_CONCAT_SPEC_CONST_CV_HANDLER, - ZEND_FAST_CONCAT_SPEC_TMP_CONST_HANDLER, - ZEND_FAST_CONCAT_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_FAST_CONCAT_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FAST_CONCAT_SPEC_CV_CONST_HANDLER, - ZEND_FAST_CONCAT_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER, + ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FAST_CONCAT_SPEC_CV_CV_HANDLER, ZEND_ROPE_INIT_SPEC_UNUSED_CONST_HANDLER, - ZEND_ROPE_INIT_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ROPE_INIT_SPEC_UNUSED_CV_HANDLER, ZEND_ROPE_ADD_SPEC_TMP_CONST_HANDLER, - ZEND_ROPE_ADD_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER, + ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ROPE_ADD_SPEC_TMP_CV_HANDLER, ZEND_ROPE_END_SPEC_TMP_CONST_HANDLER, - ZEND_ROPE_END_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER, + ZEND_ROPE_END_SPEC_TMP_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ROPE_END_SPEC_TMP_CV_HANDLER, ZEND_BEGIN_SILENCE_SPEC_HANDLER, @@ -116843,8 +123574,8 @@ void zend_vm_init(void) ZEND_RETURN_SPEC_OBSERVER_HANDLER, ZEND_RETURN_SPEC_TMP_HANDLER, ZEND_RETURN_SPEC_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_RETURN_SPEC_VAR_HANDLER, + ZEND_RETURN_SPEC_OBSERVER_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_RETURN_SPEC_CV_HANDLER, @@ -116959,43 +123690,43 @@ void zend_vm_init(void) ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER, ZEND_FREE_SPEC_TMPVAR_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER, - ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER, ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER, - ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER, + ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_HANDLER, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER, ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER, ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER, - ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER, + ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_HANDLER, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER, ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER, - ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER, ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER, ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER, - ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER, + ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_HANDLER, ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER, ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER, - ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER, - ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER, - ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117004,16 +123735,16 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER, - ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER, - ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER, @@ -117034,8 +123765,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER, - ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER, + ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117044,8 +123775,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER, - ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER, + ZEND_UNSET_DIM_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117059,44 +123790,44 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER, - ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER, + ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER, - ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER, ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER, - ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER, ZEND_FE_RESET_R_SPEC_CONST_HANDLER, ZEND_FE_RESET_R_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FE_RESET_R_SPEC_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FE_RESET_R_SPEC_CV_HANDLER, - ZEND_FE_FETCH_R_SPEC_TMP_HANDLER, + ZEND_FE_FETCH_R_SPEC_VAR_HANDLER, ZEND_FETCH_R_SPEC_CONST_UNUSED_HANDLER, - ZEND_FETCH_R_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_R_SPEC_CV_UNUSED_HANDLER, ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER, - ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER, + ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER, - ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_HANDLER, - ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117105,38 +123836,38 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_CONST_CV_HANDLER, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_HANDLER, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_HANDLER, ZEND_FETCH_OBJ_R_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_CV_CV_HANDLER, ZEND_FETCH_W_SPEC_CONST_UNUSED_HANDLER, - ZEND_FETCH_W_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_W_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, @@ -117150,8 +123881,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_HANDLER, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER, ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117160,8 +123891,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_HANDLER, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER, ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117175,23 +123906,23 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER, - ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER, ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER, ZEND_FETCH_RW_SPEC_CONST_UNUSED_HANDLER, - ZEND_FETCH_RW_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_RW_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, @@ -117205,8 +123936,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_HANDLER, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER, ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117215,8 +123946,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_HANDLER, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER, ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117230,38 +123961,38 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER, - ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER, ZEND_FETCH_IS_SPEC_CONST_UNUSED_HANDLER, - ZEND_FETCH_IS_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_IS_SPEC_CV_UNUSED_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_HANDLER, - ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CONST_CV_HANDLER, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER, - ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_HANDLER, - ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117270,53 +124001,53 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER, - ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_HANDLER, - ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_HANDLER, - ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117325,38 +124056,38 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER, - ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, @@ -117370,8 +124101,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117380,8 +124111,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117395,33 +124126,33 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER, - ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER, - ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER, ZEND_FETCH_LIST_R_SPEC_CONST_CONST_HANDLER, - ZEND_FETCH_LIST_R_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER, + ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_LIST_R_SPEC_CONST_CV_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER, - ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER, - ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117430,8 +124161,8 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_HANDLER, - ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_HANDLER, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER, @@ -117457,18 +124188,18 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_CATCH_SPEC_CONST_HANDLER, ZEND_THROW_SPEC_CONST_HANDLER, - ZEND_THROW_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_THROW_SPEC_TMPVAR_HANDLER, + ZEND_THROW_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_THROW_SPEC_CV_HANDLER, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_HANDLER, - ZEND_FETCH_CLASS_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_HANDLER, ZEND_FETCH_CLASS_SPEC_UNUSED_CV_HANDLER, ZEND_CLONE_SPEC_CONST_HANDLER, - ZEND_CLONE_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_CLONE_SPEC_TMPVAR_HANDLER, + ZEND_CLONE_SPEC_TMPVAR_HANDLER, ZEND_CLONE_SPEC_UNUSED_HANDLER, ZEND_CLONE_SPEC_CV_HANDLER, ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER, @@ -117482,33 +124213,33 @@ void zend_vm_init(void) ZEND_RETURN_BY_REF_SPEC_CV_HANDLER, ZEND_RETURN_BY_REF_SPEC_OBSERVER_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117517,13 +124248,13 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117532,33 +124263,33 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER, - ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER, ZEND_SEND_VAL_EX_SPEC_CONST_CONST_HANDLER, @@ -117637,25 +124368,25 @@ void zend_vm_init(void) ZEND_SEND_VAR_SPEC_CV_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CONST_HANDLER, - ZEND_INIT_USER_CALL_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER, + ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CV_HANDLER, ZEND_SEND_ARRAY_SPEC_HANDLER, ZEND_SEND_USER_SPEC_CONST_HANDLER, ZEND_SEND_USER_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_SEND_USER_SPEC_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_SEND_USER_SPEC_CV_HANDLER, ZEND_STRLEN_SPEC_CONST_HANDLER, - ZEND_STRLEN_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_STRLEN_SPEC_TMPVAR_HANDLER, + ZEND_STRLEN_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_STRLEN_SPEC_CV_HANDLER, ZEND_DEFINED_SPEC_CONST_HANDLER, ZEND_TYPE_CHECK_SPEC_CONST_HANDLER, - ZEND_TYPE_CHECK_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER, + ZEND_TYPE_CHECK_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_TYPE_CHECK_SPEC_CV_HANDLER, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_HANDLER, @@ -117671,8 +124402,8 @@ void zend_vm_init(void) ZEND_FE_FETCH_RW_SPEC_VAR_HANDLER, ZEND_FE_FREE_SPEC_TMPVAR_HANDLER, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_HANDLER, - ZEND_INIT_DYNAMIC_CALL_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER, + ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_INIT_DYNAMIC_CALL_SPEC_CV_HANDLER, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_HANDLER, @@ -117698,18 +124429,18 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_HANDLER, - ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_VAR_CV_HANDLER, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_HANDLER, - ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_HANDLER, ZEND_PRE_INC_OBJ_SPEC_CV_CONST_HANDLER, - ZEND_PRE_INC_OBJ_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_CV_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117723,23 +124454,23 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_POST_INC_OBJ_SPEC_VAR_CONST_HANDLER, - ZEND_POST_INC_OBJ_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER, + ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_POST_INC_OBJ_SPEC_VAR_CV_HANDLER, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_HANDLER, - ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_HANDLER, ZEND_POST_INC_OBJ_SPEC_CV_CONST_HANDLER, - ZEND_POST_INC_OBJ_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_POST_INC_OBJ_SPEC_CV_CV_HANDLER, ZEND_ECHO_SPEC_CONST_HANDLER, - ZEND_ECHO_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ECHO_SPEC_TMPVAR_HANDLER, + ZEND_ECHO_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ECHO_SPEC_CV_HANDLER, ZEND_NULL_HANDLER, @@ -117748,15 +124479,15 @@ void zend_vm_init(void) ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, - ZEND_INSTANCEOF_SPEC_TMP_CONST_HANDLER, - ZEND_NULL_HANDLER, - ZEND_INSTANCEOF_SPEC_TMP_VAR_HANDLER, - ZEND_INSTANCEOF_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER, ZEND_NULL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_HANDLER, ZEND_NULL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, @@ -117782,28 +124513,28 @@ void zend_vm_init(void) ZEND_DECLARE_ANON_CLASS_SPEC_HANDLER, ZEND_ADD_ARRAY_UNPACK_SPEC_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER, ZEND_HANDLE_EXCEPTION_SPEC_HANDLER, @@ -117811,49 +124542,49 @@ void zend_vm_init(void) ZEND_ASSERT_CHECK_SPEC_HANDLER, ZEND_JMP_SET_SPEC_CONST_HANDLER, ZEND_JMP_SET_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_JMP_SET_SPEC_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_JMP_SET_SPEC_CV_HANDLER, ZEND_UNSET_CV_SPEC_CV_UNUSED_HANDLER, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_HANDLER, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_HANDLER, ZEND_FETCH_LIST_W_SPEC_VAR_CONST_HANDLER, - ZEND_FETCH_LIST_W_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER, + ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_FETCH_LIST_W_SPEC_VAR_CV_HANDLER, ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, - ZEND_FETCH_CLASS_NAME_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER, + ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_HANDLER, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_HANDLER, ZEND_FETCH_CLASS_NAME_SPEC_CV_HANDLER, ZEND_CALL_TRAMPOLINE_SPEC_HANDLER, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_HANDLER, ZEND_DISCARD_EXCEPTION_SPEC_HANDLER, ZEND_YIELD_SPEC_CONST_CONST_HANDLER, - ZEND_YIELD_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER, + ZEND_YIELD_SPEC_CONST_TMPVAR_HANDLER, ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER, ZEND_YIELD_SPEC_CONST_CV_HANDLER, ZEND_YIELD_SPEC_TMP_CONST_HANDLER, - ZEND_YIELD_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER, + ZEND_YIELD_SPEC_TMP_TMPVAR_HANDLER, ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER, ZEND_YIELD_SPEC_TMP_CV_HANDLER, ZEND_YIELD_SPEC_VAR_CONST_HANDLER, - ZEND_YIELD_SPEC_VAR_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER, + ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER, ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER, ZEND_YIELD_SPEC_VAR_CV_HANDLER, ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER, - ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER, + ZEND_YIELD_SPEC_UNUSED_TMPVAR_HANDLER, ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER, ZEND_YIELD_SPEC_UNUSED_CV_HANDLER, ZEND_YIELD_SPEC_CV_CONST_HANDLER, - ZEND_YIELD_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER, + ZEND_YIELD_SPEC_CV_TMPVAR_HANDLER, ZEND_YIELD_SPEC_CV_UNUSED_HANDLER, ZEND_YIELD_SPEC_CV_CV_HANDLER, ZEND_GENERATOR_RETURN_SPEC_CONST_HANDLER, @@ -117871,40 +124602,40 @@ void zend_vm_init(void) ZEND_RECV_VARIADIC_SPEC_UNUSED_HANDLER, ZEND_SEND_UNPACK_SPEC_HANDLER, ZEND_YIELD_FROM_SPEC_CONST_HANDLER, - ZEND_YIELD_FROM_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER, + ZEND_YIELD_FROM_SPEC_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_YIELD_FROM_SPEC_CV_HANDLER, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_BIND_GLOBAL_SPEC_CV_CONST_HANDLER, ZEND_COALESCE_SPEC_CONST_HANDLER, ZEND_COALESCE_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_COALESCE_SPEC_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_COALESCE_SPEC_CV_HANDLER, ZEND_SPACESHIP_SPEC_CONST_CONST_HANDLER, - ZEND_SPACESHIP_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER, + ZEND_SPACESHIP_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_SPACESHIP_SPEC_CONST_CV_HANDLER, - ZEND_SPACESHIP_SPEC_TMP_CONST_HANDLER, - ZEND_SPACESHIP_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_SPACESHIP_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_CONST_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_SPACESHIP_SPEC_CV_CONST_HANDLER, - ZEND_SPACESHIP_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER, + ZEND_SPACESHIP_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_SPACESHIP_SPEC_CV_CV_HANDLER, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_HANDLER, @@ -117967,48 +124698,48 @@ void zend_vm_init(void) ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_HANDLER, ZEND_IN_ARRAY_SPEC_CONST_CONST_HANDLER, ZEND_IN_ARRAY_SPEC_TMP_CONST_HANDLER, - ZEND_NULL_HANDLER, + ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLER, ZEND_NULL_HANDLER, ZEND_IN_ARRAY_SPEC_CV_CONST_HANDLER, ZEND_COUNT_SPEC_CONST_UNUSED_HANDLER, - ZEND_COUNT_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_COUNT_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_COUNT_SPEC_CV_UNUSED_HANDLER, ZEND_GET_CLASS_SPEC_CONST_UNUSED_HANDLER, - ZEND_GET_CLASS_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_HANDLER, ZEND_GET_CLASS_SPEC_CV_UNUSED_HANDLER, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_HANDLER, ZEND_GET_TYPE_SPEC_CONST_UNUSED_HANDLER, ZEND_GET_TYPE_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_GET_TYPE_SPEC_VAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_GET_TYPE_SPEC_CV_UNUSED_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_HANDLER, ZEND_NULL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_NULL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_HANDLER, ZEND_NULL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_HANDLER, ZEND_MATCH_SPEC_CONST_CONST_HANDLER, @@ -118016,11 +124747,31 @@ void zend_vm_init(void) ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER, ZEND_NULL_HANDLER, ZEND_MATCH_SPEC_TMPVARCV_CONST_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_CASE_STRICT_SPEC_TMP_CONST_HANDLER, ZEND_CASE_STRICT_SPEC_TMP_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_CASE_STRICT_SPEC_TMP_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_CASE_STRICT_SPEC_TMP_CV_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_CONST_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_TMP_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_CV_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_HANDLER, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER, @@ -118028,7 +124779,7 @@ void zend_vm_init(void) ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_HANDLER, ZEND_JMP_NULL_SPEC_CONST_HANDLER, ZEND_JMP_NULL_SPEC_TMP_HANDLER, - ZEND_NULL_HANDLER, + ZEND_JMP_NULL_SPEC_VAR_HANDLER, ZEND_NULL_HANDLER, ZEND_JMP_NULL_SPEC_CV_HANDLER, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_HANDLER, @@ -118047,12 +124798,11 @@ void zend_vm_init(void) ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_HANDLER, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_HANDLER, - ZEND_TYPE_ASSERT_SPEC_CONST_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_NULL_HANDLER, - ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED_HANDLER, - ZEND_NULL_HANDLER, + ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER, + ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_HANDLER, ZEND_NULL_HANDLER, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_HANDLER, ZEND_JMP_FORWARD_SPEC_HANDLER, @@ -119044,28 +125794,28 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_MUL_SPEC_TMPVARCV_TMPVARCV_TAILCALL_HANDLER, ZEND_DIV_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_DIV_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_DIV_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_DIV_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_DIV_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_DIV_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_DIV_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_DIV_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_DIV_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_DIV_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_DIV_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_DIV_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_DIV_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_DIV_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_MOD_SPEC_CONST_CONST_TAILCALL_HANDLER, @@ -119144,28 +125894,28 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_SR_SPEC_TMPVARCV_TMPVARCV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_CONCAT_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_CONCAT_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_CONCAT_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_CONCAT_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_CONCAT_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_CONCAT_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_CONCAT_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_CONCAT_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_CONCAT_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_BW_OR_SPEC_CONST_CONST_TAILCALL_HANDLER, @@ -119244,28 +125994,28 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_BW_XOR_SPEC_TMPVARCV_TMPVARCV_TAILCALL_HANDLER, ZEND_POW_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_POW_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_POW_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_POW_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_POW_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_POW_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_POW_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_POW_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_POW_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_POW_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_POW_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_POW_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_POW_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_POW_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_POW_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_POW_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_POW_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_POW_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_POW_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_POW_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_POW_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_BW_NOT_SPEC_CONST_TAILCALL_HANDLER, @@ -119274,8 +126024,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_BW_NOT_SPEC_TMPVARCV_TAILCALL_HANDLER, ZEND_BOOL_NOT_SPEC_CONST_TAILCALL_HANDLER, - ZEND_BOOL_NOT_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_BOOL_NOT_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_BOOL_NOT_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_BOOL_NOT_SPEC_CV_TAILCALL_HANDLER, ZEND_BOOL_XOR_SPEC_CONST_CONST_TAILCALL_HANDLER, @@ -119283,14 +126033,14 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_BOOL_XOR_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_BOOL_XOR_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_BOOL_XOR_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119299,8 +126049,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_BOOL_XOR_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_BOOL_XOR_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_BOOL_XOR_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_BOOL_XOR_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_BOOL_XOR_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_IS_IDENTICAL_SPEC_CONST_CONST_TAILCALL_HANDLER, @@ -119313,9 +126063,9 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_IDENTICAL_SPEC_VAR_CONST_TAILCALL_HANDLER, + ZEND_IS_IDENTICAL_SPEC_VAR_TMP_TAILCALL_HANDLER, + ZEND_IS_IDENTICAL_SPEC_VAR_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119325,7 +126075,7 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_IS_IDENTICAL_SPEC_CV_CONST_TAILCALL_HANDLER, ZEND_IS_IDENTICAL_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_IDENTICAL_SPEC_CV_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_IS_IDENTICAL_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_TAILCALL_HANDLER, @@ -119338,9 +126088,9 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_TAILCALL_HANDLER, + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_TAILCALL_HANDLER, + ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119350,7 +126100,7 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_TAILCALL_HANDLER, ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_IS_EQUAL_SPEC_CONST_CONST_TAILCALL_HANDLER, @@ -119368,69 +126118,42 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPZ_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_CONST_JMPNZ_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPZ_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_TMP_TMP_JMPNZ_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_TMP_JMPZ_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_TMP_JMPNZ_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_CV_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_TAILCALL_HANDLER, - ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119440,15 +126163,24 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_CONST_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_CONST_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_CONST_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_TMPVAR_JMPNZ_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPZ_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_JMPNZ_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPZ_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_CV_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_CV_JMPZ_TAILCALL_HANDLER, + ZEND_IS_EQUAL_SPEC_CV_CV_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119461,12 +126193,30 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_CONST_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_TMPVAR_TMPVAR_JMPNZ_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119491,12 +126241,12 @@ void zend_vm_init(void) ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_TAILCALL_HANDLER, ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPZ_TAILCALL_HANDLER, ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_JMPNZ_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPZ_TAILCALL_HANDLER, - ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_JMPNZ_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPZ_TAILCALL_HANDLER, + ZEND_IS_NOT_EQUAL_SPEC_CV_TMPVAR_JMPNZ_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119677,8 +126427,8 @@ void zend_vm_init(void) ZEND_ASSIGN_SPEC_VAR_CONST_RETVAL_USED_TAILCALL_HANDLER, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_UNUSED_TAILCALL_HANDLER, ZEND_ASSIGN_SPEC_VAR_TMP_RETVAL_USED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_UNUSED_TAILCALL_HANDLER, + ZEND_ASSIGN_SPEC_VAR_VAR_RETVAL_USED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_SPEC_VAR_CV_RETVAL_UNUSED_TAILCALL_HANDLER, @@ -119697,8 +126447,8 @@ void zend_vm_init(void) ZEND_ASSIGN_SPEC_CV_CONST_RETVAL_USED_TAILCALL_HANDLER, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_UNUSED_TAILCALL_HANDLER, ZEND_ASSIGN_SPEC_CV_TMP_RETVAL_USED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_UNUSED_TAILCALL_HANDLER, + ZEND_ASSIGN_SPEC_CV_VAR_RETVAL_USED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_SPEC_CV_CV_RETVAL_UNUSED_TAILCALL_HANDLER, @@ -119755,27 +126505,27 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CONST_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_DIM_SPEC_VAR_TMP_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_OP_DATA_CV_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_VAR_CV_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119805,27 +126555,27 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CONST_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_DIM_SPEC_CV_TMP_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_OP_DATA_CV_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_SPEC_CV_CV_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119880,19 +126630,19 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119900,24 +126650,24 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA_CV_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119925,24 +126675,24 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_DATA_CV_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_SPEC_CV_TMP_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CONST_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_TMP_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119950,12 +126700,12 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_CV_TAILCALL_HANDLER, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CONST_TAILCALL_HANDLER, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_STATIC_PROP_SPEC_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119969,8 +126719,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OP_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_OP_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ASSIGN_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OP_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119979,8 +126729,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OP_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_OP_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_ASSIGN_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OP_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -119994,8 +126744,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120004,8 +126754,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_DIM_OP_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_ASSIGN_DIM_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_ASSIGN_DIM_OP_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120019,18 +126769,18 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_OP_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ASSIGN_OBJ_OP_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_ASSIGN_STATIC_PROP_OP_SPEC_TAILCALL_HANDLER, @@ -120121,14 +126871,14 @@ void zend_vm_init(void) ZEND_ASSIGN_OBJ_REF_SPEC_VAR_CONST_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_VAR_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMP_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_VAR_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120146,14 +126896,14 @@ void zend_vm_init(void) ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_CONST_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_VAR_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMP_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_UNUSED_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120171,14 +126921,14 @@ void zend_vm_init(void) ZEND_ASSIGN_OBJ_REF_SPEC_CV_CONST_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_VAR_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMP_OP_DATA_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ASSIGN_OBJ_REF_SPEC_CV_TMPVAR_OP_DATA_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120224,30 +126974,30 @@ void zend_vm_init(void) ZEND_POST_INC_STATIC_PROP_SPEC_TAILCALL_HANDLER, ZEND_JMP_SPEC_TAILCALL_HANDLER, ZEND_JMPZ_SPEC_CONST_TAILCALL_HANDLER, - ZEND_JMPZ_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_JMPZ_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_JMPZ_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_JMPZ_SPEC_CV_TAILCALL_HANDLER, ZEND_JMPNZ_SPEC_CONST_TAILCALL_HANDLER, - ZEND_JMPNZ_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_JMPNZ_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_JMPNZ_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_JMPNZ_SPEC_CV_TAILCALL_HANDLER, ZEND_JMPZ_EX_SPEC_CONST_TAILCALL_HANDLER, - ZEND_JMPZ_EX_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_JMPZ_EX_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_JMPZ_EX_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_JMPZ_EX_SPEC_CV_TAILCALL_HANDLER, ZEND_JMPNZ_EX_SPEC_CONST_TAILCALL_HANDLER, - ZEND_JMPNZ_EX_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_JMPNZ_EX_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_JMPNZ_EX_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_JMPNZ_EX_SPEC_CV_TAILCALL_HANDLER, - ZEND_CASE_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_CASE_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_CASE_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_CASE_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_CASE_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_CASE_SPEC_TMP_CV_TAILCALL_HANDLER, + ZEND_CASE_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_CHECK_VAR_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_TAILCALL_HANDLER, ZEND_SEND_VAR_NO_REF_EX_SPEC_VAR_CONST_TAILCALL_HANDLER, @@ -120261,52 +127011,52 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_CAST_SPEC_CONST_TAILCALL_HANDLER, ZEND_CAST_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_CAST_SPEC_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_CAST_SPEC_CV_TAILCALL_HANDLER, ZEND_BOOL_SPEC_CONST_TAILCALL_HANDLER, - ZEND_BOOL_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_BOOL_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_BOOL_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_BOOL_SPEC_CV_TAILCALL_HANDLER, ZEND_FAST_CONCAT_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_FAST_CONCAT_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FAST_CONCAT_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_FAST_CONCAT_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_FAST_CONCAT_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_FAST_CONCAT_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FAST_CONCAT_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FAST_CONCAT_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FAST_CONCAT_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FAST_CONCAT_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_ROPE_INIT_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_ROPE_INIT_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_ROPE_INIT_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ROPE_INIT_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_ROPE_ADD_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_ROPE_ADD_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, + ZEND_ROPE_ADD_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ROPE_ADD_SPEC_TMP_CV_TAILCALL_HANDLER, ZEND_ROPE_END_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_ROPE_END_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ROPE_END_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, + ZEND_ROPE_END_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ROPE_END_SPEC_TMP_CV_TAILCALL_HANDLER, ZEND_BEGIN_SILENCE_SPEC_TAILCALL_HANDLER, @@ -120321,8 +127071,8 @@ void zend_vm_init(void) ZEND_RETURN_SPEC_OBSERVER_TAILCALL_HANDLER, ZEND_RETURN_SPEC_TMP_TAILCALL_HANDLER, ZEND_RETURN_SPEC_OBSERVER_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_RETURN_SPEC_VAR_TAILCALL_HANDLER, + ZEND_RETURN_SPEC_OBSERVER_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_RETURN_SPEC_CV_TAILCALL_HANDLER, @@ -120437,43 +127187,43 @@ void zend_vm_init(void) ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_TAILCALL_HANDLER, ZEND_FREE_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_INIT_ARRAY_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_INIT_ARRAY_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_TMP_CV_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_INIT_ARRAY_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_INIT_ARRAY_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_ARRAY_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_INIT_ARRAY_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120482,16 +127232,16 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_CONST_TAILCALL_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_TAILCALL_HANDLER, - ZEND_INCLUDE_OR_EVAL_SPEC_TMP_TAILCALL_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_TAILCALL_HANDLER, + ZEND_INCLUDE_OR_EVAL_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_OBSERVER_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_INCLUDE_OR_EVAL_SPEC_CV_TAILCALL_HANDLER, @@ -120512,8 +127262,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_UNSET_DIM_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_UNSET_DIM_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_UNSET_DIM_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_UNSET_DIM_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120522,8 +127272,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_UNSET_DIM_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_UNSET_DIM_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_UNSET_DIM_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_UNSET_DIM_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_UNSET_DIM_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120537,44 +127287,44 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_UNSET_OBJ_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_UNSET_OBJ_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_UNSET_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_UNSET_OBJ_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_UNSET_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_UNSET_OBJ_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_UNSET_OBJ_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_UNSET_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_UNSET_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_UNSET_OBJ_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FE_RESET_R_SPEC_CONST_TAILCALL_HANDLER, ZEND_FE_RESET_R_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FE_RESET_R_SPEC_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FE_RESET_R_SPEC_CV_TAILCALL_HANDLER, - ZEND_FE_FETCH_R_SPEC_TMP_TAILCALL_HANDLER, + ZEND_FE_FETCH_R_SPEC_VAR_TAILCALL_HANDLER, ZEND_FETCH_R_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_FETCH_R_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_FETCH_R_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_R_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_R_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_R_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_R_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120583,38 +127333,38 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_R_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_R_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_R_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_R_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_R_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_R_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_R_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_W_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_FETCH_W_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_FETCH_W_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_W_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120628,8 +127378,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_W_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_W_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_W_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120638,8 +127388,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_W_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_W_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_W_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_W_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120653,23 +127403,23 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_W_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_W_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_W_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_RW_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_FETCH_RW_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_FETCH_RW_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_RW_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120683,8 +127433,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_RW_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_RW_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120693,8 +127443,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_RW_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_RW_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_RW_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_RW_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120708,38 +127458,38 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_RW_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_RW_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_IS_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_FETCH_IS_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_FETCH_IS_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_IS_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_IS_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120748,53 +127498,53 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_IS_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_IS_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_IS_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_IS_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_IS_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_FETCH_FUNC_ARG_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_TMP_CV_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120803,38 +127553,38 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_TMP_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_FETCH_UNSET_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_UNSET_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120848,8 +127598,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120858,8 +127608,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_DIM_UNSET_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120873,33 +127623,33 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FETCH_LIST_R_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_FETCH_LIST_R_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_LIST_R_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_TAILCALL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120908,8 +127658,8 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CONST_TAILCALL_HANDLER, - ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_LIST_R_SPEC_TMPVARCV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_LIST_R_SPEC_TMPVARCV_CV_TAILCALL_HANDLER, ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_TAILCALL_HANDLER, @@ -120935,18 +127685,18 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_CATCH_SPEC_CONST_TAILCALL_HANDLER, ZEND_THROW_SPEC_CONST_TAILCALL_HANDLER, - ZEND_THROW_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_THROW_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_THROW_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_THROW_SPEC_CV_TAILCALL_HANDLER, ZEND_FETCH_CLASS_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_FETCH_CLASS_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_CLASS_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_CLASS_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_CLASS_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_CLONE_SPEC_CONST_TAILCALL_HANDLER, - ZEND_CLONE_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_CLONE_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_CLONE_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_CLONE_SPEC_UNUSED_TAILCALL_HANDLER, ZEND_CLONE_SPEC_CV_TAILCALL_HANDLER, ZEND_RETURN_BY_REF_SPEC_CONST_TAILCALL_HANDLER, @@ -120960,33 +127710,33 @@ void zend_vm_init(void) ZEND_RETURN_BY_REF_SPEC_CV_TAILCALL_HANDLER, ZEND_RETURN_BY_REF_SPEC_OBSERVER_TAILCALL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_METHOD_CALL_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_METHOD_CALL_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -120995,13 +127745,13 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER, ZEND_INIT_STATIC_METHOD_CALL_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -121010,33 +127760,33 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_VAR_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_SEND_VAL_EX_SPEC_CONST_CONST_TAILCALL_HANDLER, @@ -121115,25 +127865,25 @@ void zend_vm_init(void) ZEND_SEND_VAR_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_INIT_USER_CALL_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_USER_CALL_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_USER_CALL_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_SEND_ARRAY_SPEC_TAILCALL_HANDLER, ZEND_SEND_USER_SPEC_CONST_TAILCALL_HANDLER, ZEND_SEND_USER_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_SEND_USER_SPEC_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_SEND_USER_SPEC_CV_TAILCALL_HANDLER, ZEND_STRLEN_SPEC_CONST_TAILCALL_HANDLER, - ZEND_STRLEN_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_STRLEN_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_STRLEN_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_STRLEN_SPEC_CV_TAILCALL_HANDLER, ZEND_DEFINED_SPEC_CONST_TAILCALL_HANDLER, ZEND_TYPE_CHECK_SPEC_CONST_TAILCALL_HANDLER, - ZEND_TYPE_CHECK_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_TYPE_CHECK_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_TYPE_CHECK_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_TYPE_CHECK_SPEC_CV_TAILCALL_HANDLER, ZEND_VERIFY_RETURN_TYPE_SPEC_CONST_UNUSED_TAILCALL_HANDLER, @@ -121149,8 +127899,8 @@ void zend_vm_init(void) ZEND_FE_FETCH_RW_SPEC_VAR_TAILCALL_HANDLER, ZEND_FE_FREE_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_INIT_DYNAMIC_CALL_SPEC_CONST_TAILCALL_HANDLER, - ZEND_INIT_DYNAMIC_CALL_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_INIT_DYNAMIC_CALL_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_INIT_DYNAMIC_CALL_SPEC_CV_TAILCALL_HANDLER, ZEND_DO_ICALL_SPEC_RETVAL_UNUSED_TAILCALL_HANDLER, @@ -121176,18 +127926,18 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_PRE_INC_OBJ_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_PRE_INC_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_PRE_INC_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_PRE_INC_OBJ_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -121201,23 +127951,23 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_POST_INC_OBJ_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_POST_INC_OBJ_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_POST_INC_OBJ_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_POST_INC_OBJ_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_POST_INC_OBJ_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_POST_INC_OBJ_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_POST_INC_OBJ_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_POST_INC_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_POST_INC_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_POST_INC_OBJ_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_ECHO_SPEC_CONST_TAILCALL_HANDLER, - ZEND_ECHO_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ECHO_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_ECHO_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ECHO_SPEC_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -121226,15 +127976,15 @@ void zend_vm_init(void) ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_INSTANCEOF_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_INSTANCEOF_SPEC_TMP_VAR_TAILCALL_HANDLER, - ZEND_INSTANCEOF_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_TAILCALL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_VAR_TAILCALL_HANDLER, + ZEND_INSTANCEOF_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, @@ -121260,28 +128010,28 @@ void zend_vm_init(void) ZEND_DECLARE_ANON_CLASS_SPEC_TAILCALL_HANDLER, ZEND_ADD_ARRAY_UNPACK_SPEC_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_HANDLE_EXCEPTION_SPEC_TAILCALL_HANDLER, @@ -121289,49 +128039,49 @@ void zend_vm_init(void) ZEND_ASSERT_CHECK_SPEC_TAILCALL_HANDLER, ZEND_JMP_SET_SPEC_CONST_TAILCALL_HANDLER, ZEND_JMP_SET_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_JMP_SET_SPEC_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_JMP_SET_SPEC_CV_TAILCALL_HANDLER, ZEND_UNSET_CV_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_SET_TAILCALL_HANDLER, ZEND_ISSET_ISEMPTY_CV_SPEC_CV_UNUSED_EMPTY_TAILCALL_HANDLER, ZEND_FETCH_LIST_W_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_FETCH_LIST_W_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_LIST_W_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_FETCH_LIST_W_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_SEPARATE_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_FETCH_CLASS_NAME_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_FETCH_CLASS_NAME_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_FETCH_CLASS_NAME_SPEC_UNUSED_TAILCALL_HANDLER, ZEND_FETCH_CLASS_NAME_SPEC_CV_TAILCALL_HANDLER, ZEND_CALL_TRAMPOLINE_SPEC_TAILCALL_HANDLER, ZEND_CALL_TRAMPOLINE_SPEC_OBSERVER_TAILCALL_HANDLER, ZEND_DISCARD_EXCEPTION_SPEC_TAILCALL_HANDLER, ZEND_YIELD_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_YIELD_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_YIELD_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_YIELD_SPEC_CONST_CV_TAILCALL_HANDLER, ZEND_YIELD_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_YIELD_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_TMP_TMPVAR_TAILCALL_HANDLER, ZEND_YIELD_SPEC_TMP_UNUSED_TAILCALL_HANDLER, ZEND_YIELD_SPEC_TMP_CV_TAILCALL_HANDLER, ZEND_YIELD_SPEC_VAR_CONST_TAILCALL_HANDLER, - ZEND_YIELD_SPEC_VAR_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_VAR_TMPVAR_TAILCALL_HANDLER, ZEND_YIELD_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_YIELD_SPEC_VAR_CV_TAILCALL_HANDLER, ZEND_YIELD_SPEC_UNUSED_CONST_TAILCALL_HANDLER, - ZEND_YIELD_SPEC_UNUSED_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_UNUSED_TMPVAR_TAILCALL_HANDLER, ZEND_YIELD_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER, ZEND_YIELD_SPEC_UNUSED_CV_TAILCALL_HANDLER, ZEND_YIELD_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_YIELD_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_YIELD_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_YIELD_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_YIELD_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_GENERATOR_RETURN_SPEC_CONST_TAILCALL_HANDLER, @@ -121349,40 +128099,40 @@ void zend_vm_init(void) ZEND_RECV_VARIADIC_SPEC_UNUSED_TAILCALL_HANDLER, ZEND_SEND_UNPACK_SPEC_TAILCALL_HANDLER, ZEND_YIELD_FROM_SPEC_CONST_TAILCALL_HANDLER, - ZEND_YIELD_FROM_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_YIELD_FROM_SPEC_TMPVAR_TAILCALL_HANDLER, + ZEND_YIELD_FROM_SPEC_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_YIELD_FROM_SPEC_CV_TAILCALL_HANDLER, ZEND_COPY_TMP_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_BIND_GLOBAL_SPEC_CV_CONST_TAILCALL_HANDLER, ZEND_COALESCE_SPEC_CONST_TAILCALL_HANDLER, ZEND_COALESCE_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_COALESCE_SPEC_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_COALESCE_SPEC_CV_TAILCALL_HANDLER, ZEND_SPACESHIP_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_SPACESHIP_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_SPACESHIP_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_SPACESHIP_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_SPACESHIP_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_SPACESHIP_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_SPACESHIP_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_SPACESHIP_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_SPACESHIP_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_SPACESHIP_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_FUNC_NUM_ARGS_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER, @@ -121445,48 +128195,48 @@ void zend_vm_init(void) ZEND_SWITCH_STRING_SPEC_TMPVARCV_CONST_TAILCALL_HANDLER, ZEND_IN_ARRAY_SPEC_CONST_CONST_TAILCALL_HANDLER, ZEND_IN_ARRAY_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_IN_ARRAY_SPEC_VAR_CONST_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_IN_ARRAY_SPEC_CV_CONST_TAILCALL_HANDLER, ZEND_COUNT_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_COUNT_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_COUNT_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_COUNT_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_COUNT_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_GET_CLASS_SPEC_CONST_UNUSED_TAILCALL_HANDLER, - ZEND_GET_CLASS_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_GET_CLASS_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_GET_CLASS_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER, ZEND_GET_CLASS_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_GET_CALLED_CLASS_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER, ZEND_GET_TYPE_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_GET_TYPE_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_GET_TYPE_SPEC_VAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_GET_TYPE_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CONST_CV_TAILCALL_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CONST_TAILCALL_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_TMP_CV_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CONST_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_TMPVAR_CV_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CONST_TAILCALL_HANDLER, - ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_TAILCALL_HANDLER, + ZEND_ARRAY_KEY_EXISTS_SPEC_CV_TMPVAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_ARRAY_KEY_EXISTS_SPEC_CV_CV_TAILCALL_HANDLER, ZEND_MATCH_SPEC_CONST_CONST_TAILCALL_HANDLER, @@ -121494,11 +128244,31 @@ void zend_vm_init(void) ZEND_MATCH_SPEC_TMPVARCV_CONST_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_MATCH_SPEC_TMPVARCV_CONST_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, ZEND_CASE_STRICT_SPEC_TMP_CONST_TAILCALL_HANDLER, ZEND_CASE_STRICT_SPEC_TMP_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_CASE_STRICT_SPEC_TMP_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_CASE_STRICT_SPEC_TMP_CV_TAILCALL_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_CONST_TAILCALL_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_TMP_TAILCALL_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_VAR_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_CASE_STRICT_SPEC_VAR_CV_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, + ZEND_NULL_TAILCALL_HANDLER, ZEND_MATCH_ERROR_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_TAILCALL_HANDLER, ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_TAILCALL_HANDLER, @@ -121506,7 +128276,7 @@ void zend_vm_init(void) ZEND_MATCH_ERROR_SPEC_TMPVARCV_UNUSED_TAILCALL_HANDLER, ZEND_JMP_NULL_SPEC_CONST_TAILCALL_HANDLER, ZEND_JMP_NULL_SPEC_TMP_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_JMP_NULL_SPEC_VAR_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_JMP_NULL_SPEC_CV_TAILCALL_HANDLER, ZEND_CHECK_UNDEF_ARGS_SPEC_UNUSED_UNUSED_TAILCALL_HANDLER, @@ -121525,12 +128295,11 @@ void zend_vm_init(void) ZEND_JMP_FRAMELESS_SPEC_CONST_TAILCALL_HANDLER, ZEND_INIT_PARENT_PROPERTY_HOOK_CALL_SPEC_CONST_UNUSED_TAILCALL_HANDLER, ZEND_DECLARE_ATTRIBUTED_CONST_SPEC_CONST_CONST_TAILCALL_HANDLER, - ZEND_TYPE_ASSERT_SPEC_CONST_TAILCALL_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_TAILCALL_HANDLER, ZEND_RECV_NOTYPE_SPEC_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, - ZEND_COUNT_ARRAY_SPEC_TMP_UNUSED_TAILCALL_HANDLER, - ZEND_NULL_TAILCALL_HANDLER, + ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, + ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED_TAILCALL_HANDLER, ZEND_NULL_TAILCALL_HANDLER, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED_TAILCALL_HANDLER, ZEND_JMP_FORWARD_SPEC_TAILCALL_HANDLER, @@ -122494,7 +129263,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3474, + 3493, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -122528,7 +129297,7 @@ void zend_vm_init(void) 1559 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1584 | SPEC_RULE_OP1, 1589, - 3474, + 3493, 1590 | SPEC_RULE_OP1, 1595 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 1620 | SPEC_RULE_OP1 | SPEC_RULE_OP2, @@ -122645,66 +129414,66 @@ void zend_vm_init(void) 2492 | SPEC_RULE_OP1, 2497 | SPEC_RULE_OP1 | SPEC_RULE_OP2, 2522 | SPEC_RULE_OP1, - 2527 | SPEC_RULE_OP2, - 2532 | SPEC_RULE_OP1, - 2537 | SPEC_RULE_OP1, - 2542, - 2543, - 2544, - 2545, - 2546, - 2547 | SPEC_RULE_OBSERVER, - 2549 | SPEC_RULE_OBSERVER, - 2551 | SPEC_RULE_OBSERVER, - 2553 | SPEC_RULE_OBSERVER, - 2555, - 2556, - 2557, - 2558, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, - 3474, + 2527 | SPEC_RULE_OP1 | SPEC_RULE_OP2, + 2552 | SPEC_RULE_OP1, + 2557 | SPEC_RULE_OP1, + 2562, + 2563, + 2564, + 2565, + 2566, + 2567 | SPEC_RULE_OBSERVER, + 2569 | SPEC_RULE_OBSERVER, + 2571 | SPEC_RULE_OBSERVER, + 2573 | SPEC_RULE_OBSERVER, + 2575, + 2576, + 2577, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, + 3493, }; #if 0 #elif (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) @@ -122881,7 +129650,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2567 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2586 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -122889,7 +129658,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2592 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2611 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -122897,7 +129666,7 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2617 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2636 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -122908,17 +129677,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2642 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2661 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2667 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2686 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2692 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2711 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -122929,17 +129698,17 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2717 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2736 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_LONG && op2_info == MAY_BE_LONG) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2742 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2761 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2767 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2786 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -122950,16 +129719,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2792 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2867 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { - spec = 3092 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3111 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3098 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3117 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -122970,16 +129739,16 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2942 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3017 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op2_type == IS_CONST && (Z_TYPE_P(RT_CONSTANT(op, op->op2)) == IS_ARRAY && zend_hash_num_elements(Z_ARR_P(RT_CONSTANT(op, op->op2))) == 0)) { - spec = 3095 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3114 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op->op1_type == IS_CV && (op->op2_type & (IS_CONST|IS_CV)) && !(op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) && !(op2_info & (MAY_BE_UNDEF|MAY_BE_REF))) { - spec = 3103 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3122 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -122990,12 +129759,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2792 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2811 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2867 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2886 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -123006,12 +129775,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 2942 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2961 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3017 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3036 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -123019,12 +129788,12 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3108 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3127 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3183 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3202 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -123032,79 +129801,79 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3258 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3277 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } else if (op1_info == MAY_BE_DOUBLE && op2_info == MAY_BE_DOUBLE) { if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3333 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3352 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_OP1; + spec = 3439 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3425 | SPEC_RULE_OP1; + spec = 3444 | SPEC_RULE_OP1; } else if ((op->op1_type == IS_CONST) ? !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1)) : (!(op1_info & ((MAY_BE_ANY|MAY_BE_UNDEF)-(MAY_BE_NULL|MAY_BE_FALSE|MAY_BE_TRUE|MAY_BE_LONG|MAY_BE_DOUBLE))))) { - spec = 3430 | SPEC_RULE_OP1; + spec = 3449 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3408 | SPEC_RULE_RETVAL; + spec = 3427 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3410 | SPEC_RULE_RETVAL; + spec = 3429 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3412 | SPEC_RULE_RETVAL; + spec = 3431 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3414 | SPEC_RULE_RETVAL; + spec = 3433 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3416; + spec = 3435; } else if (op1_info == MAY_BE_LONG) { - spec = 3417; + spec = 3436; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3418; + spec = 3437; } else if (op1_info == MAY_BE_LONG) { - spec = 3419; + spec = 3438; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2566; + spec = 2585; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2559; + spec = 2578; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2560; + spec = 2579; } break; case ZEND_SEND_VAL: if (op->op1_type == IS_CONST && op->op2_type == IS_UNUSED && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3470; + spec = 3489; } break; case ZEND_SEND_VAR_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3465 | SPEC_RULE_OP1; + spec = 3484 | SPEC_RULE_OP1; } break; case ZEND_FE_FETCH_R: if (op->op2_type == IS_CV && (op1_info & (MAY_BE_ANY|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 3472 | SPEC_RULE_RETVAL; + spec = 3491 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -123112,22 +129881,22 @@ ZEND_API void ZEND_FASTCALL zend_vm_set_opcode_handler_ex(zend_op* op, uint32_t if (op->op1_type == IS_CONST && op->op2_type == IS_CONST) { break; } - spec = 3435 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3454 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_SEND_VAL_EX: if (op->op2_type == IS_UNUSED && op->op2.num <= MAX_ARG_FLAG_NUM && op->op1_type == IS_CONST && !Z_REFCOUNTED_P(RT_CONSTANT(op, op->op1))) { - spec = 3471; + spec = 3490; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3460 | SPEC_RULE_OP1; + spec = 3479 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2561 | SPEC_RULE_OP1; + spec = 2580 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/configure.ac b/configure.ac index 07d64902ebf0b..66dd91e0c9ed0 100644 --- a/configure.ac +++ b/configure.ac @@ -1757,6 +1757,7 @@ PHP_ADD_SOURCES([Zend], m4_normalize([ zend_frameless_function.c zend_gc.c zend_gdb.c + zend_generics.c zend_generators.c zend_hash.c zend_highlight.c diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c index 2a9b4776350bc..b73c417b5062d 100644 --- a/ext/reflection/php_reflection.c +++ b/ext/reflection/php_reflection.c @@ -51,6 +51,7 @@ #include "zend_smart_str.h" #include "zend_enum.h" #include "zend_fibers.h" +#include "zend_generics.h" #define REFLECTION_ATTRIBUTE_IS_INSTANCEOF (1 << 1) @@ -104,6 +105,7 @@ PHPAPI zend_class_entry *reflection_enum_unit_case_ptr; PHPAPI zend_class_entry *reflection_enum_backed_case_ptr; PHPAPI zend_class_entry *reflection_fiber_ptr; PHPAPI zend_class_entry *reflection_constant_ptr; +PHPAPI zend_class_entry *reflection_generic_parameter_ptr; PHPAPI zend_class_entry *reflection_property_hook_type_ptr; /* Exception throwing macro */ @@ -159,6 +161,12 @@ typedef struct _attribute_reference { uint32_t target; } attribute_reference; +/* Struct for generic type parameters */ +typedef struct _generic_parameter_reference { + zend_generic_param *param; + zend_generic_params_info *params_info; +} generic_parameter_reference; + typedef enum { REF_TYPE_OTHER, /* Must be 0 */ REF_TYPE_FUNCTION, @@ -168,7 +176,8 @@ typedef enum { REF_TYPE_TYPE, REF_TYPE_PROPERTY, REF_TYPE_CLASS_CONSTANT, - REF_TYPE_ATTRIBUTE + REF_TYPE_ATTRIBUTE, + REF_TYPE_GENERIC_PARAMETER } reflection_type_t; /* Struct for reflection objects */ @@ -270,6 +279,9 @@ static void reflection_free_objects_storage(zend_object *object) /* {{{ */ efree(intern->ptr); break; } + case REF_TYPE_GENERIC_PARAMETER: + efree(intern->ptr); + break; case REF_TYPE_GENERATOR: case REF_TYPE_FIBER: case REF_TYPE_CLASS_CONSTANT: @@ -8115,6 +8127,231 @@ ZEND_METHOD(ReflectionConstant, __toString) RETURN_STR(smart_str_extract(&str)); } +/* {{{ ReflectionGenericParameter factory */ +static void reflection_generic_parameter_factory(zend_generic_param *param, zend_generic_params_info *params_info, zval *object) +{ + reflection_object *intern; + generic_parameter_reference *reference; + + object_init_ex(object, reflection_generic_parameter_ptr); + intern = Z_REFLECTION_P(object); + + reference = (generic_parameter_reference *) emalloc(sizeof(generic_parameter_reference)); + reference->param = param; + reference->params_info = params_info; + + intern->ptr = reference; + intern->ref_type = REF_TYPE_GENERIC_PARAMETER; + + ZVAL_STR_COPY(reflection_prop_name(object), param->name); +} +/* }}} */ + +/* {{{ Returns whether the class is generic */ +ZEND_METHOD(ReflectionClass, isGeneric) +{ + reflection_object *intern; + zend_class_entry *ce; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(ce); + RETURN_BOOL(ce->generic_params_info != NULL); +} +/* }}} */ + +/* {{{ Returns an array of ReflectionGenericParameter for the class's generic type parameters */ +ZEND_METHOD(ReflectionClass, getGenericParameters) +{ + reflection_object *intern; + zend_class_entry *ce; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(ce); + + array_init(return_value); + + if (ce->generic_params_info) { + uint32_t i; + for (i = 0; i < ce->generic_params_info->num_params; i++) { + zval param_obj; + reflection_generic_parameter_factory( + &ce->generic_params_info->params[i], + ce->generic_params_info, + ¶m_obj + ); + zend_hash_next_index_insert(Z_ARRVAL_P(return_value), ¶m_obj); + } + } +} +/* }}} */ + +/* {{{ Returns an array of ReflectionType for the object's bound generic type arguments */ +ZEND_METHOD(ReflectionObject, getGenericArguments) +{ + reflection_object *intern; + + ZEND_PARSE_PARAMETERS_NONE(); + + intern = Z_REFLECTION_P(ZEND_THIS); + + array_init(return_value); + + if (!Z_ISUNDEF(intern->obj)) { + zend_object *obj = Z_OBJ(intern->obj); + + if (obj->generic_args) { + uint32_t i; + for (i = 0; i < obj->generic_args->num_args; i++) { + zval type_obj; + reflection_type_factory(obj->generic_args->args[i], &type_obj, 0); + zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &type_obj); + } + } + } +} +/* }}} */ + +/* {{{ Returns whether the function is generic */ +ZEND_METHOD(ReflectionFunctionAbstract, isGeneric) +{ + reflection_object *intern; + zend_function *fptr; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(fptr); + + if (fptr->type == ZEND_USER_FUNCTION) { + RETURN_BOOL(fptr->op_array.generic_params_info != NULL); + } + RETURN_FALSE; +} +/* }}} */ + +/* {{{ Returns an array of ReflectionGenericParameter for the function's generic type parameters */ +ZEND_METHOD(ReflectionFunctionAbstract, getGenericParameters) +{ + reflection_object *intern; + zend_function *fptr; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(fptr); + + array_init(return_value); + + if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.generic_params_info) { + uint32_t i; + for (i = 0; i < fptr->op_array.generic_params_info->num_params; i++) { + zval param_obj; + reflection_generic_parameter_factory( + &fptr->op_array.generic_params_info->params[i], + fptr->op_array.generic_params_info, + ¶m_obj + ); + zend_hash_next_index_insert(Z_ARRVAL_P(return_value), ¶m_obj); + } + } +} +/* }}} */ + +/* {{{ Returns the string representation of the generic parameter */ +ZEND_METHOD(ReflectionGenericParameter, __toString) +{ + reflection_object *intern; + generic_parameter_reference *param; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(param); + + smart_str str = {0}; + + if (param->param->variance == ZEND_GENERIC_VARIANCE_COVARIANT) { + smart_str_appends(&str, "out "); + } else if (param->param->variance == ZEND_GENERIC_VARIANCE_CONTRAVARIANT) { + smart_str_appends(&str, "in "); + } + + smart_str_append(&str, param->param->name); + + if (ZEND_TYPE_IS_SET(param->param->constraint)) { + smart_str_appends(&str, ": "); + zend_string *type_str = zend_type_to_string(param->param->constraint); + smart_str_append(&str, type_str); + zend_string_release(type_str); + } + + RETURN_STR(smart_str_extract(&str)); +} +/* }}} */ + +/* {{{ Returns the name of the generic parameter */ +ZEND_METHOD(ReflectionGenericParameter, getName) +{ + reflection_object *intern; + generic_parameter_reference *param; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(param); + + RETURN_STR_COPY(param->param->name); +} +/* }}} */ + +/* {{{ Returns the constraint type, or null if unconstrained */ +ZEND_METHOD(ReflectionGenericParameter, getConstraint) +{ + reflection_object *intern; + generic_parameter_reference *param; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(param); + + if (ZEND_TYPE_IS_SET(param->param->constraint)) { + reflection_type_factory(param->param->constraint, return_value, 0); + } else { + RETURN_NULL(); + } +} +/* }}} */ + +/* {{{ Returns true if the parameter is covariant (out) */ +ZEND_METHOD(ReflectionGenericParameter, isCovariant) +{ + reflection_object *intern; + generic_parameter_reference *param; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(param); + + RETURN_BOOL(param->param->variance == ZEND_GENERIC_VARIANCE_COVARIANT); +} +/* }}} */ + +/* {{{ Returns true if the parameter is contravariant (in) */ +ZEND_METHOD(ReflectionGenericParameter, isContravariant) +{ + reflection_object *intern; + generic_parameter_reference *param; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(param); + + RETURN_BOOL(param->param->variance == ZEND_GENERIC_VARIANCE_CONTRAVARIANT); +} +/* }}} */ + +/* {{{ Returns true if the parameter is invariant (no variance annotation) */ +ZEND_METHOD(ReflectionGenericParameter, isInvariant) +{ + reflection_object *intern; + generic_parameter_reference *param; + + ZEND_PARSE_PARAMETERS_NONE(); + GET_REFLECTION_OBJECT_PTR(param); + + RETURN_BOOL(param->param->variance == ZEND_GENERIC_VARIANCE_INVARIANT); +} +/* }}} */ + PHP_MINIT_FUNCTION(reflection) /* {{{ */ { memcpy(&reflection_object_handlers, &std_object_handlers, sizeof(zend_object_handlers)); @@ -8218,6 +8455,10 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */ reflection_constant_ptr->create_object = reflection_objects_new; reflection_constant_ptr->default_object_handlers = &reflection_object_handlers; + reflection_generic_parameter_ptr = register_class_ReflectionGenericParameter(reflector_ptr); + reflection_generic_parameter_ptr->create_object = reflection_objects_new; + reflection_generic_parameter_ptr->default_object_handlers = &reflection_object_handlers; + reflection_property_hook_type_ptr = register_class_PropertyHookType(); REFLECTION_G(key_initialized) = false; diff --git a/ext/reflection/php_reflection.h b/ext/reflection/php_reflection.h index dc22407342985..a3b962bdb7e58 100644 --- a/ext/reflection/php_reflection.h +++ b/ext/reflection/php_reflection.h @@ -49,6 +49,7 @@ extern PHPAPI zend_class_entry *reflection_enum_unit_case_ptr; extern PHPAPI zend_class_entry *reflection_enum_backed_case_ptr; extern PHPAPI zend_class_entry *reflection_fiber_ptr; extern PHPAPI zend_class_entry *reflection_lazy_object_ptr; +extern PHPAPI zend_class_entry *reflection_generic_parameter_ptr; PHPAPI void zend_reflection_class_factory(zend_class_entry *ce, zval *object); diff --git a/ext/reflection/php_reflection.stub.php b/ext/reflection/php_reflection.stub.php index b0273a3174f8e..0a01c697ef376 100644 --- a/ext/reflection/php_reflection.stub.php +++ b/ext/reflection/php_reflection.stub.php @@ -115,6 +115,11 @@ public function hasTentativeReturnType(): bool {} public function getTentativeReturnType(): ?ReflectionType {} public function getAttributes(?string $name = null, int $flags = 0): array {} + + public function isGeneric(): bool {} + + /** @return ReflectionGenericParameter[] */ + public function getGenericParameters(): array {} } class ReflectionFunction extends ReflectionFunctionAbstract @@ -436,11 +441,19 @@ public function getNamespaceName(): string {} public function getShortName(): string {} public function getAttributes(?string $name = null, int $flags = 0): array {} + + public function isGeneric(): bool {} + + /** @return ReflectionGenericParameter[] */ + public function getGenericParameters(): array {} } class ReflectionObject extends ReflectionClass { public function __construct(object $object) {} + + /** @return ReflectionType[] */ + public function getGenericArguments(): array {} } enum PropertyHookType: string @@ -907,6 +920,27 @@ public function getCallable(): callable {} public function getTrace(int $options = DEBUG_BACKTRACE_PROVIDE_OBJECT): array {} } +/** @not-serializable */ +final class ReflectionGenericParameter implements Reflector +{ + public string $name; + + /** @implementation-alias ReflectionClass::__clone */ + private function __clone(): void {} + + public function __toString(): string {} + + public function getName(): string {} + + public function getConstraint(): ?ReflectionType {} + + public function isCovariant(): bool {} + + public function isContravariant(): bool {} + + public function isInvariant(): bool {} +} + /** * @strict-properties * @not-serializable diff --git a/ext/reflection/php_reflection_arginfo.h b/ext/reflection/php_reflection_arginfo.h index 66605a22bbd66..050958244097f 100644 --- a/ext/reflection/php_reflection_arginfo.h +++ b/ext/reflection/php_reflection_arginfo.h @@ -87,6 +87,10 @@ ZEND_BEGIN_ARG_WITH_RETURN_TYPE_INFO_EX(arginfo_class_ReflectionFunctionAbstract ZEND_ARG_TYPE_INFO_WITH_DEFAULT_VALUE(0, flags, IS_LONG, 0, "0") ZEND_END_ARG_INFO() +#define arginfo_class_ReflectionFunctionAbstract_isGeneric arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + +#define arginfo_class_ReflectionFunctionAbstract_getGenericParameters arginfo_class_ReflectionFunctionAbstract_getClosureUsedVariables + ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionFunction___construct, 0, 0, 1) ZEND_ARG_OBJ_TYPE_MASK(0, function, Closure, MAY_BE_STRING, NULL) ZEND_END_ARG_INFO() @@ -367,10 +371,16 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionClass_getAttributes arginfo_class_ReflectionFunctionAbstract_getAttributes +#define arginfo_class_ReflectionClass_isGeneric arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + +#define arginfo_class_ReflectionClass_getGenericParameters arginfo_class_ReflectionFunctionAbstract_getClosureUsedVariables + ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionObject___construct, 0, 0, 1) ZEND_ARG_TYPE_INFO(0, object, IS_OBJECT, 0) ZEND_END_ARG_INFO() +#define arginfo_class_ReflectionObject_getGenericArguments arginfo_class_ReflectionFunctionAbstract_getClosureUsedVariables + #define arginfo_class_ReflectionProperty___clone arginfo_class_ReflectionFunctionAbstract___clone ZEND_BEGIN_ARG_INFO_EX(arginfo_class_ReflectionProperty___construct, 0, 0, 2) @@ -706,6 +716,21 @@ ZEND_END_ARG_INFO() #define arginfo_class_ReflectionFiber_getTrace arginfo_class_ReflectionGenerator_getTrace +#define arginfo_class_ReflectionGenericParameter___clone arginfo_class_ReflectionFunctionAbstract___clone + +#define arginfo_class_ReflectionGenericParameter___toString arginfo_class_ReflectionFunction___toString + +#define arginfo_class_ReflectionGenericParameter_getName arginfo_class_ReflectionFunction___toString + +ZEND_BEGIN_ARG_WITH_RETURN_OBJ_INFO_EX(arginfo_class_ReflectionGenericParameter_getConstraint, 0, 0, ReflectionType, 1) +ZEND_END_ARG_INFO() + +#define arginfo_class_ReflectionGenericParameter_isCovariant arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + +#define arginfo_class_ReflectionGenericParameter_isContravariant arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + +#define arginfo_class_ReflectionGenericParameter_isInvariant arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType + #define arginfo_class_ReflectionConstant___construct arginfo_class_ReflectionExtension___construct #define arginfo_class_ReflectionConstant_getName arginfo_class_ReflectionFunction___toString @@ -766,6 +791,8 @@ ZEND_METHOD(ReflectionFunctionAbstract, getReturnType); ZEND_METHOD(ReflectionFunctionAbstract, hasTentativeReturnType); ZEND_METHOD(ReflectionFunctionAbstract, getTentativeReturnType); ZEND_METHOD(ReflectionFunctionAbstract, getAttributes); +ZEND_METHOD(ReflectionFunctionAbstract, isGeneric); +ZEND_METHOD(ReflectionFunctionAbstract, getGenericParameters); ZEND_METHOD(ReflectionFunction, __construct); ZEND_METHOD(ReflectionFunction, __toString); ZEND_METHOD(ReflectionFunction, isAnonymous); @@ -861,7 +888,10 @@ ZEND_METHOD(ReflectionClass, inNamespace); ZEND_METHOD(ReflectionClass, getNamespaceName); ZEND_METHOD(ReflectionClass, getShortName); ZEND_METHOD(ReflectionClass, getAttributes); +ZEND_METHOD(ReflectionClass, isGeneric); +ZEND_METHOD(ReflectionClass, getGenericParameters); ZEND_METHOD(ReflectionObject, __construct); +ZEND_METHOD(ReflectionObject, getGenericArguments); ZEND_METHOD(ReflectionProperty, __construct); ZEND_METHOD(ReflectionProperty, __toString); ZEND_METHOD(ReflectionProperty, getName); @@ -994,6 +1024,12 @@ ZEND_METHOD(ReflectionFiber, getExecutingFile); ZEND_METHOD(ReflectionFiber, getExecutingLine); ZEND_METHOD(ReflectionFiber, getCallable); ZEND_METHOD(ReflectionFiber, getTrace); +ZEND_METHOD(ReflectionGenericParameter, __toString); +ZEND_METHOD(ReflectionGenericParameter, getName); +ZEND_METHOD(ReflectionGenericParameter, getConstraint); +ZEND_METHOD(ReflectionGenericParameter, isCovariant); +ZEND_METHOD(ReflectionGenericParameter, isContravariant); +ZEND_METHOD(ReflectionGenericParameter, isInvariant); ZEND_METHOD(ReflectionConstant, __construct); ZEND_METHOD(ReflectionConstant, getName); ZEND_METHOD(ReflectionConstant, inNamespace); @@ -1045,6 +1081,8 @@ static const zend_function_entry class_ReflectionFunctionAbstract_methods[] = { ZEND_ME(ReflectionFunctionAbstract, hasTentativeReturnType, arginfo_class_ReflectionFunctionAbstract_hasTentativeReturnType, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionFunctionAbstract, getTentativeReturnType, arginfo_class_ReflectionFunctionAbstract_getTentativeReturnType, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionFunctionAbstract, getAttributes, arginfo_class_ReflectionFunctionAbstract_getAttributes, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionFunctionAbstract, isGeneric, arginfo_class_ReflectionFunctionAbstract_isGeneric, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionFunctionAbstract, getGenericParameters, arginfo_class_ReflectionFunctionAbstract_getGenericParameters, ZEND_ACC_PUBLIC) ZEND_FE_END }; @@ -1158,11 +1196,14 @@ static const zend_function_entry class_ReflectionClass_methods[] = { ZEND_ME(ReflectionClass, getNamespaceName, arginfo_class_ReflectionClass_getNamespaceName, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionClass, getShortName, arginfo_class_ReflectionClass_getShortName, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionClass, getAttributes, arginfo_class_ReflectionClass_getAttributes, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionClass, isGeneric, arginfo_class_ReflectionClass_isGeneric, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionClass, getGenericParameters, arginfo_class_ReflectionClass_getGenericParameters, ZEND_ACC_PUBLIC) ZEND_FE_END }; static const zend_function_entry class_ReflectionObject_methods[] = { ZEND_ME(ReflectionObject, __construct, arginfo_class_ReflectionObject___construct, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionObject, getGenericArguments, arginfo_class_ReflectionObject_getGenericArguments, ZEND_ACC_PUBLIC) ZEND_FE_END }; @@ -1366,6 +1407,17 @@ static const zend_function_entry class_ReflectionFiber_methods[] = { ZEND_FE_END }; +static const zend_function_entry class_ReflectionGenericParameter_methods[] = { + ZEND_RAW_FENTRY("__clone", zim_ReflectionClass___clone, arginfo_class_ReflectionGenericParameter___clone, ZEND_ACC_PRIVATE, NULL, NULL) + ZEND_ME(ReflectionGenericParameter, __toString, arginfo_class_ReflectionGenericParameter___toString, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionGenericParameter, getName, arginfo_class_ReflectionGenericParameter_getName, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionGenericParameter, getConstraint, arginfo_class_ReflectionGenericParameter_getConstraint, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionGenericParameter, isCovariant, arginfo_class_ReflectionGenericParameter_isCovariant, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionGenericParameter, isContravariant, arginfo_class_ReflectionGenericParameter_isContravariant, ZEND_ACC_PUBLIC) + ZEND_ME(ReflectionGenericParameter, isInvariant, arginfo_class_ReflectionGenericParameter_isInvariant, ZEND_ACC_PUBLIC) + ZEND_FE_END +}; + static const zend_function_entry class_ReflectionConstant_methods[] = { ZEND_ME(ReflectionConstant, __construct, arginfo_class_ReflectionConstant___construct, ZEND_ACC_PUBLIC) ZEND_ME(ReflectionConstant, getName, arginfo_class_ReflectionConstant_getName, ZEND_ACC_PUBLIC) @@ -1905,6 +1957,21 @@ static zend_class_entry *register_class_ReflectionFiber(void) return class_entry; } +static zend_class_entry *register_class_ReflectionGenericParameter(zend_class_entry *class_entry_Reflector) +{ + zend_class_entry ce, *class_entry; + + INIT_CLASS_ENTRY(ce, "ReflectionGenericParameter", class_ReflectionGenericParameter_methods); + class_entry = zend_register_internal_class_with_flags(&ce, NULL, ZEND_ACC_FINAL|ZEND_ACC_NOT_SERIALIZABLE); + zend_class_implements(class_entry, 1, class_entry_Reflector); + + zval property_name_default_value; + ZVAL_UNDEF(&property_name_default_value); + zend_declare_typed_property(class_entry, ZSTR_KNOWN(ZEND_STR_NAME), &property_name_default_value, ZEND_ACC_PUBLIC, NULL, (zend_type) ZEND_TYPE_INIT_MASK(MAY_BE_STRING)); + + return class_entry; +} + static zend_class_entry *register_class_ReflectionConstant(zend_class_entry *class_entry_Reflector) { zend_class_entry ce, *class_entry; diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c index 0900c51d3d95a..8b77c68dc9c5c 100644 --- a/ext/tokenizer/tokenizer_data.c +++ b/ext/tokenizer/tokenizer_data.c @@ -176,6 +176,7 @@ char *get_token_type_name(int token_type) case T_PIPE: return "T_PIPE"; case T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG: return "T_AMPERSAND_FOLLOWED_BY_VAR_OR_VARARG"; case T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG: return "T_AMPERSAND_NOT_FOLLOWED_BY_VAR_OR_VARARG"; + case T_GENERIC_LT: return "T_GENERIC_LT"; case T_BAD_CHARACTER: return "T_BAD_CHARACTER"; } diff --git a/win32/build/config.w32 b/win32/build/config.w32 index aefcfb5f82474..a07538af0a55c 100644 --- a/win32/build/config.w32 +++ b/win32/build/config.w32 @@ -241,7 +241,7 @@ ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \ zend_float.c zend_string.c zend_generators.c zend_virtual_cwd.c zend_ast.c \ zend_inheritance.c zend_smart_str.c zend_cpuinfo.c zend_observer.c zend_system_id.c \ zend_enum.c zend_fibers.c zend_atomic.c zend_hrtime.c zend_frameless_function.c zend_property_hooks.c \ - zend_lazy_objects.c zend_autoload.c"); + zend_lazy_objects.c zend_autoload.c zend_generics.c"); ADD_SOURCES("Zend\\Optimizer", "zend_optimizer.c pass1.c pass3.c optimize_func_calls.c block_pass.c optimize_temp_vars_5.c nop_removal.c compact_literals.c zend_cfg.c zend_dfg.c dfa_pass.c zend_ssa.c zend_inference.c zend_func_info.c zend_call_graph.c zend_dump.c escape_analysis.c compact_vars.c dce.c sccp.c scdf.c"); var PHP_ASSEMBLER = PATH_PROG({ From ae0ca5d481cd463a13d017dee9cf00c1e59b3d28 Mon Sep 17 00:00:00 2001 From: php-generics <264588703+php-generics@users.noreply.github.com> Date: Sat, 28 Feb 2026 17:14:13 +0100 Subject: [PATCH 02/10] WIP --- Zend/Optimizer/compact_literals.c | 77 +- Zend/Optimizer/zend_inference.c | 5 + Zend/Optimizer/zend_optimizer.c | 18 +- .../generics/generic_anonymous_class.phpt | 47 ++ Zend/tests/generics/generic_autoloading.phpt | 31 + Zend/tests/generics/generic_class_alias.phpt | 44 + .../tests/generics/generic_debug_display.phpt | 67 ++ Zend/tests/generics/generic_default_type.phpt | 90 +++ Zend/tests/generics/generic_fibers.phpt | 47 ++ Zend/tests/generics/generic_file_cache.phpt | 77 ++ Zend/tests/generics/generic_jit.phpt | 58 ++ Zend/tests/generics/generic_opcache.phpt | 66 ++ .../generic_reject_never_extends.phpt | 11 + .../generics/generic_reject_never_new.phpt | 11 + .../generics/generic_reject_void_extends.phpt | 11 + .../generics/generic_reject_void_new.phpt | 11 + .../generic_resolved_masks_complex.phpt | 90 +++ .../generic_resolved_masks_jit_hot.phpt | 89 +++ ...eneric_resolved_masks_opcache_persist.phpt | 75 ++ .../generic_resolved_masks_scalar.phpt | 87 ++ Zend/tests/generics/generic_serialize.phpt | 84 ++ Zend/tests/generics/generic_static_call.phpt | 61 ++ .../generics/generic_weak_reference.phpt | 53 ++ .../generics/generic_wildcard_types.phpt | 101 +++ Zend/zend_ast.h | 6 +- Zend/zend_builtin_functions.c | 13 +- Zend/zend_compile.c | 125 ++- Zend/zend_execute.c | 19 +- Zend/zend_execute_API.c | 6 + Zend/zend_generics.c | 270 ++++++- Zend/zend_generics.h | 32 +- Zend/zend_language_parser.y | 75 +- Zend/zend_language_scanner.l | 24 + Zend/zend_object_handlers.c | 3 +- Zend/zend_opcode.c | 9 + Zend/zend_vm_def.h | 40 +- Zend/zend_vm_execute.h | 756 ++++++++++++++---- ext/opcache/jit/zend_jit_helpers.c | 60 ++ ext/opcache/jit/zend_jit_ir.c | 141 ++++ ext/opcache/zend_file_cache.c | 199 +++++ ext/opcache/zend_persist.c | 90 +++ ext/opcache/zend_persist_calc.c | 82 ++ ext/reflection/php_reflection.c | 30 + ext/reflection/php_reflection.stub.php | 4 + ext/reflection/php_reflection_arginfo.h | 8 + ext/standard/var.c | 29 +- ext/standard/var_unserializer.re | 43 +- 47 files changed, 3156 insertions(+), 219 deletions(-) create mode 100644 Zend/tests/generics/generic_anonymous_class.phpt create mode 100644 Zend/tests/generics/generic_autoloading.phpt create mode 100644 Zend/tests/generics/generic_class_alias.phpt create mode 100644 Zend/tests/generics/generic_debug_display.phpt create mode 100644 Zend/tests/generics/generic_default_type.phpt create mode 100644 Zend/tests/generics/generic_fibers.phpt create mode 100644 Zend/tests/generics/generic_file_cache.phpt create mode 100644 Zend/tests/generics/generic_jit.phpt create mode 100644 Zend/tests/generics/generic_opcache.phpt create mode 100644 Zend/tests/generics/generic_reject_never_extends.phpt create mode 100644 Zend/tests/generics/generic_reject_never_new.phpt create mode 100644 Zend/tests/generics/generic_reject_void_extends.phpt create mode 100644 Zend/tests/generics/generic_reject_void_new.phpt create mode 100644 Zend/tests/generics/generic_resolved_masks_complex.phpt create mode 100644 Zend/tests/generics/generic_resolved_masks_jit_hot.phpt create mode 100644 Zend/tests/generics/generic_resolved_masks_opcache_persist.phpt create mode 100644 Zend/tests/generics/generic_resolved_masks_scalar.phpt create mode 100644 Zend/tests/generics/generic_serialize.phpt create mode 100644 Zend/tests/generics/generic_static_call.phpt create mode 100644 Zend/tests/generics/generic_weak_reference.phpt create mode 100644 Zend/tests/generics/generic_wildcard_types.phpt diff --git a/Zend/Optimizer/compact_literals.c b/Zend/Optimizer/compact_literals.c index 447a034530e1b..39b30779fa11a 100644 --- a/Zend/Optimizer/compact_literals.c +++ b/Zend/Optimizer/compact_literals.c @@ -94,11 +94,28 @@ static zend_string *create_str_cache_key(zval *literal, uint8_t num_related) Z_STRVAL_P(literal), Z_STRLEN_P(literal), Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1)); } else if (num_related == 3) { - ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING && Z_TYPE_P(literal + 2) == IS_STRING); - key = zend_string_concat3( - Z_STRVAL_P(literal), Z_STRLEN_P(literal), - Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1), - Z_STRVAL_P(literal + 2), Z_STRLEN_P(literal + 2)); + if (Z_TYPE_P(literal + 2) == IS_PTR || Z_TYPE_P(literal + 2) == IS_LONG) { + /* Generic args literal (IS_PTR or IS_LONG pointer) — include pointer value + * in key to prevent merging across different generic instantiations */ + char ptr_buf[32]; + uintptr_t ptr_val = (Z_TYPE_P(literal + 2) == IS_PTR) + ? (uintptr_t)Z_PTR_P(literal + 2) + : (uintptr_t)Z_LVAL_P(literal + 2); + int ptr_len = snprintf(ptr_buf, sizeof(ptr_buf), "G%lx", (unsigned long)ptr_val); + ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING); + size_t len = Z_STRLEN_P(literal) + Z_STRLEN_P(literal + 1) + ptr_len; + key = zend_string_alloc(len, 0); + memcpy(ZSTR_VAL(key), Z_STRVAL_P(literal), Z_STRLEN_P(literal)); + memcpy(ZSTR_VAL(key) + Z_STRLEN_P(literal), Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1)); + memcpy(ZSTR_VAL(key) + Z_STRLEN_P(literal) + Z_STRLEN_P(literal + 1), ptr_buf, ptr_len); + ZSTR_VAL(key)[len] = '\0'; + } else { + ZEND_ASSERT(Z_TYPE_P(literal + 1) == IS_STRING && Z_TYPE_P(literal + 2) == IS_STRING); + key = zend_string_concat3( + Z_STRVAL_P(literal), Z_STRLEN_P(literal), + Z_STRVAL_P(literal + 1), Z_STRLEN_P(literal + 1), + Z_STRVAL_P(literal + 2), Z_STRLEN_P(literal + 2)); + } } else { ZEND_ASSERT(0 && "Currently not needed"); } @@ -151,7 +168,8 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx break; case ZEND_INIT_STATIC_METHOD_CALL: if (opline->op1_type == IS_CONST) { - LITERAL_INFO(opline->op1.constant, 2); + LITERAL_INFO(opline->op1.constant, + (opline->result.num & 0x80000000) ? 3 : 2); } if (opline->op2_type == IS_CONST) { LITERAL_INFO(opline->op2.constant, 2); @@ -201,14 +219,20 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx } break; case ZEND_FETCH_CLASS: - case ZEND_INSTANCEOF: if (opline->op2_type == IS_CONST) { LITERAL_INFO(opline->op2.constant, 2); } break; + case ZEND_INSTANCEOF: + if (opline->op2_type == IS_CONST) { + LITERAL_INFO(opline->op2.constant, + (opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG) ? 3 : 2); + } + break; case ZEND_NEW: if (opline->op1_type == IS_CONST) { - LITERAL_INFO(opline->op1.constant, 2); + LITERAL_INFO(opline->op1.constant, + (opline->op2.num & 0x80000000) ? 3 : 2); } break; case ZEND_DECLARE_CLASS: @@ -569,7 +593,8 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx } } break; - case ZEND_INIT_STATIC_METHOD_CALL: + case ZEND_INIT_STATIC_METHOD_CALL: { + uint32_t generic_flag = opline->result.num & 0x80000000; if (opline->op2_type == IS_CONST) { // op2 static method if (opline->op1_type == IS_CONST) { @@ -577,22 +602,23 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx opline->op1.constant, opline->op2.constant, LITERAL_STATIC_METHOD, - &cache_size); + &cache_size) | generic_flag; } else { - opline->result.num = cache_size; + opline->result.num = cache_size | generic_flag; cache_size += 2 * sizeof(void *); } } else if (opline->op1_type == IS_CONST) { // op1 class if (class_slot[opline->op1.constant] >= 0) { - opline->result.num = class_slot[opline->op1.constant]; + opline->result.num = class_slot[opline->op1.constant] | generic_flag; } else { - opline->result.num = cache_size; + opline->result.num = cache_size | generic_flag; cache_size += sizeof(void *); - class_slot[opline->op1.constant] = opline->result.num; + class_slot[opline->op1.constant] = cache_size - sizeof(void *); } } break; + } case ZEND_DEFINED: // op1 const if (const_slot[opline->op1.constant] >= 0) { @@ -666,7 +692,6 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx } break; case ZEND_FETCH_CLASS: - case ZEND_INSTANCEOF: if (opline->op2_type == IS_CONST) { // op2 class if (class_slot[opline->op2.constant] >= 0) { @@ -678,15 +703,29 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx } } break; + case ZEND_INSTANCEOF: + if (opline->op2_type == IS_CONST) { + // op2 class — preserve generic flag + uint32_t generic_flag = opline->extended_value & ZEND_INSTANCEOF_GENERIC_FLAG; + if (class_slot[opline->op2.constant] >= 0) { + opline->extended_value = class_slot[opline->op2.constant] | generic_flag; + } else { + opline->extended_value = cache_size | generic_flag; + cache_size += sizeof(void *); + class_slot[opline->op2.constant] = cache_size - sizeof(void *); + } + } + break; case ZEND_NEW: if (opline->op1_type == IS_CONST) { - // op1 class + // op1 class — preserve generic flag + uint32_t generic_flag = opline->op2.num & 0x80000000; if (class_slot[opline->op1.constant] >= 0) { - opline->op2.num = class_slot[opline->op1.constant]; + opline->op2.num = class_slot[opline->op1.constant] | generic_flag; } else { - opline->op2.num = cache_size; + opline->op2.num = cache_size | generic_flag; cache_size += sizeof(void *); - class_slot[opline->op1.constant] = opline->op2.num; + class_slot[opline->op1.constant] = cache_size - sizeof(void *); } } break; diff --git a/Zend/Optimizer/zend_inference.c b/Zend/Optimizer/zend_inference.c index 6963fc63dd15c..298fcc92a9447 100644 --- a/Zend/Optimizer/zend_inference.c +++ b/Zend/Optimizer/zend_inference.c @@ -2383,6 +2383,11 @@ static uint32_t zend_convert_type(const zend_script *script, zend_type type, zen return MAY_BE_ANY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF|MAY_BE_RC1|MAY_BE_RCN; } + /* Generic type parameters can resolve to any type at runtime */ + if (ZEND_TYPE_IS_GENERIC_PARAM(type)) { + return MAY_BE_ANY|MAY_BE_ARRAY_KEY_ANY|MAY_BE_ARRAY_OF_ANY|MAY_BE_ARRAY_OF_REF|MAY_BE_RC1|MAY_BE_RCN; + } + uint32_t tmp = zend_convert_type_declaration_mask(ZEND_TYPE_PURE_MASK(type)); if (ZEND_TYPE_IS_COMPLEX(type)) { tmp |= MAY_BE_OBJECT; diff --git a/Zend/Optimizer/zend_optimizer.c b/Zend/Optimizer/zend_optimizer.c index f8cbefdaaf2b5..85cf8a215305f 100644 --- a/Zend/Optimizer/zend_optimizer.c +++ b/Zend/Optimizer/zend_optimizer.c @@ -301,22 +301,32 @@ bool zend_optimizer_update_op1_const(zend_op_array *op_array, opline->extended_value = alloc_cache_slots(op_array, 1); zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val))); break; - case ZEND_NEW: + case ZEND_NEW: { + uint32_t generic_flag = opline->op2.num & 0x80000000; REQUIRES_STRING(val); drop_leading_backslash(val); opline->op1.constant = zend_optimizer_add_literal(op_array, val); - opline->op2.num = alloc_cache_slots(op_array, 1); + opline->op2.num = alloc_cache_slots(op_array, 1) | generic_flag; zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val))); + if (generic_flag) { + /* Copy the generic args IS_PTR literal (was at old op1.constant + 2) */ + /* Note: the generic args are already in the literal table from compilation, + * but we need to add a placeholder since the optimizer rebuilds literals. + * The actual IS_PTR will be re-added by the caller. */ + } break; - case ZEND_INIT_STATIC_METHOD_CALL: + } + case ZEND_INIT_STATIC_METHOD_CALL: { + uint32_t generic_flag = opline->result.num & 0x80000000; REQUIRES_STRING(val); drop_leading_backslash(val); opline->op1.constant = zend_optimizer_add_literal(op_array, val); if (opline->op2_type != IS_CONST) { - opline->result.num = alloc_cache_slots(op_array, 1); + opline->result.num = alloc_cache_slots(op_array, 1) | generic_flag; } zend_optimizer_add_literal_string(op_array, zend_string_tolower(Z_STR_P(val))); break; + } case ZEND_FETCH_CLASS_CONSTANT: REQUIRES_STRING(val); drop_leading_backslash(val); diff --git a/Zend/tests/generics/generic_anonymous_class.phpt b/Zend/tests/generics/generic_anonymous_class.phpt new file mode 100644 index 0000000000000..21a6137e45384 --- /dev/null +++ b/Zend/tests/generics/generic_anonymous_class.phpt @@ -0,0 +1,47 @@ +--TEST-- +Generic class: anonymous classes extending generic classes +--FILE-- + { + public function __construct(public T $value) {} + public function get(): T { return $this->value; } +} + +// Anonymous class extending generic with bound args +$obj = new class(42) extends Box {}; +echo $obj->get() . "\n"; + +// Type enforcement works +try { + $obj->value = "not an int"; +} catch (TypeError $e) { + echo "TypeError: type enforced\n"; +} + +// Anonymous class can override methods +$obj2 = new class("hello") extends Box { + public function get(): string { + return strtoupper(parent::get()); + } +}; +echo $obj2->get() . "\n"; + +// Anonymous class implementing generic interface +interface Getter { + public function get(): T; +} + +$obj3 = new class implements Getter { + public function get(): int { return 99; } +}; +echo $obj3->get() . "\n"; + +echo "OK\n"; +?> +--EXPECTF-- +42 +TypeError: type enforced +HELLO +99 +OK diff --git a/Zend/tests/generics/generic_autoloading.phpt b/Zend/tests/generics/generic_autoloading.phpt new file mode 100644 index 0000000000000..7c1e006e16d53 --- /dev/null +++ b/Zend/tests/generics/generic_autoloading.phpt @@ -0,0 +1,31 @@ +--TEST-- +Generic class: autoloading triggers for base class name +--FILE-- + { public function __construct(public T $value) {} public function get(): T { return $this->value; } }'); + } +}); + +// new with generic args triggers autoload for base class +$b = new AutoBox(42); +echo $b->get() . "\n"; +var_dump($b); + +// Verify autoloader received the base class name (no generics) +echo "Autoloaded: " . implode(", ", $autoloaded) . "\n"; + +echo "OK\n"; +?> +--EXPECTF-- +42 +object(AutoBox)#%d (1) { + ["value"]=> + int(42) +} +Autoloaded: AutoBox +OK diff --git a/Zend/tests/generics/generic_class_alias.phpt b/Zend/tests/generics/generic_class_alias.phpt new file mode 100644 index 0000000000000..a20ac44f9fa56 --- /dev/null +++ b/Zend/tests/generics/generic_class_alias.phpt @@ -0,0 +1,44 @@ +--TEST-- +Generic class: class_alias works with generic classes +--FILE-- + { + public function __construct(public T $value) {} + public function get(): T { return $this->value; } +} + +class_alias('Box', 'Container'); + +// Alias with generic args +$c = new Container(42); +echo $c->get() . "\n"; +var_dump($c); + +// get_class returns the original class name +echo get_class($c) . "\n"; + +// instanceof works +echo ($c instanceof Box) ? "instanceof Box: yes\n" : "instanceof Box: no\n"; +echo ($c instanceof Container) ? "instanceof Container: yes\n" : "instanceof Container: no\n"; + +// Type enforcement works through alias +try { + $c->value = "not an int"; +} catch (TypeError $e) { + echo "TypeError: type enforced\n"; +} + +echo "OK\n"; +?> +--EXPECTF-- +42 +object(Box)#1 (1) { + ["value"]=> + int(42) +} +Box +instanceof Box: yes +instanceof Container: yes +TypeError: type enforced +OK diff --git a/Zend/tests/generics/generic_debug_display.phpt b/Zend/tests/generics/generic_debug_display.phpt new file mode 100644 index 0000000000000..77ff044e53c43 --- /dev/null +++ b/Zend/tests/generics/generic_debug_display.phpt @@ -0,0 +1,67 @@ +--TEST-- +Generic class: debug display with var_dump, print_r, and stack traces +--FILE-- + { + public function __construct(public T $value) {} + public function throwError(): void { + throw new RuntimeException("test"); + } +} + +class Pair { + public function __construct(public A $first, public B $second) {} +} + +// var_dump shows generic args +$b = new Box(42); +var_dump($b); + +// print_r shows generic args +echo "---\n"; +$p = new Pair("hello", 99); +print_r($p); + +// get_class returns raw class name (no generic args) +echo "---\n"; +echo get_class($b) . "\n"; +echo get_class($p) . "\n"; + +// Stack trace shows generic args +echo "---\n"; +try { + $b->throwError(); +} catch (Throwable $e) { + echo $e->getTraceAsString() . "\n"; +} + +// Inherited class with bound generic args +class IntBox extends Box {} +$ib = new IntBox(100); +var_dump($ib); + +echo "OK\n"; +?> +--EXPECTF-- +object(Box)#1 (1) { + ["value"]=> + int(42) +} +--- +Pair Object +( + [first] => hello + [second] => 99 +) +--- +Box +Pair +--- +#0 %s(%d): Box->throwError() +#1 {main} +object(IntBox)#%d (1) { + ["value"]=> + int(100) +} +OK diff --git a/Zend/tests/generics/generic_default_type.phpt b/Zend/tests/generics/generic_default_type.phpt new file mode 100644 index 0000000000000..a1e2f51b095e3 --- /dev/null +++ b/Zend/tests/generics/generic_default_type.phpt @@ -0,0 +1,90 @@ +--TEST-- +Generic class: default type parameters +--FILE-- + { + public function __construct(public T $value) {} + public function get(): T { return $this->value; } +} + +// With explicit type arg — overrides default +$c1 = new Container(42); +echo $c1->get() . "\n"; // 42 + +// Without type arg — uses default (string) +$c2 = new Container("hello"); +echo $c2->get() . "\n"; // hello + +// Using default via fewer args +$c3 = new Container("world"); +echo $c3->get() . "\n"; // world (inferred as string) + +// Multiple params with partial defaults +class Map { + /** @var array */ + private array $items = []; + + public function set(K $key, V $value): void { + $this->items[] = [$key, $value]; + } + + public function getLastValue(): V { + $last = end($this->items); + return $last[1]; + } +} + +// Provide both args +$m1 = new Map(); +$m1->set(1, "one"); +echo $m1->getLastValue() . "\n"; // one + +// Provide only K, V defaults to string +$m2 = new Map(); +$m2->set(1, "default_v"); +echo $m2->getLastValue() . "\n"; // default_v + +// Type enforcement with default +try { + $m3 = new Map(); + $m3->set(1, 42); // Should fail: V=string but got int +} catch (TypeError $e) { + echo "TypeError: V enforced\n"; +} + +// Default with constraint +class Repository { + public static function describe(): string { + return "Repository"; + } +} + +$r = new Repository(); +echo Repository::describe() . "\n"; + +// Reflection +$rc = new ReflectionClass('Map'); +$params = $rc->getGenericParameters(); +echo "Map params: " . count($params) . "\n"; +echo " K: hasDefault=" . var_export($params[0]->hasDefaultType(), true) . "\n"; +echo " V: hasDefault=" . var_export($params[1]->hasDefaultType(), true) . "\n"; +echo " V default: " . $params[1]->getDefaultType() . "\n"; + +echo "OK\n"; +?> +--EXPECTF-- +42 +hello +world +one +default_v +TypeError: V enforced +Repository +Map params: 2 + K: hasDefault=false + V: hasDefault=true + V default: string +OK diff --git a/Zend/tests/generics/generic_fibers.phpt b/Zend/tests/generics/generic_fibers.phpt new file mode 100644 index 0000000000000..3d96c0ee94f5b --- /dev/null +++ b/Zend/tests/generics/generic_fibers.phpt @@ -0,0 +1,47 @@ +--TEST-- +Generic class: generic objects work across fiber suspend/resume +--FILE-- + { + public function __construct(public T $value) {} + public function get(): T { return $this->value; } +} + +$fiber = new Fiber(function () { + $b = new Box(42); + echo "Fiber: " . $b->get() . "\n"; + + // Suspend and pass a generic object out + Fiber::suspend($b); + + // After resume, modify and check type enforcement + $b->value = 100; + echo "Fiber resumed: " . $b->get() . "\n"; + + try { + $b->value = "not an int"; + } catch (TypeError $e) { + echo "Fiber TypeError: type enforced\n"; + } +}); + +// Start the fiber and receive the generic object +$box = $fiber->start(); +echo "Main received: "; +var_dump($box); + +// Resume the fiber +$fiber->resume(); + +echo "OK\n"; +?> +--EXPECTF-- +Fiber: 42 +Main received: object(Box)#%d (1) { + ["value"]=> + int(42) +} +Fiber resumed: 100 +Fiber TypeError: type enforced +OK diff --git a/Zend/tests/generics/generic_file_cache.phpt b/Zend/tests/generics/generic_file_cache.phpt new file mode 100644 index 0000000000000..581eb0a61b0fc --- /dev/null +++ b/Zend/tests/generics/generic_file_cache.phpt @@ -0,0 +1,77 @@ +--TEST-- +Generic classes work with opcache file cache +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.file_cache={TMP} +opcache.file_cache_only=1 +--FILE-- + { + private T $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +class Pair { + public function __construct(private K $key, private V $val) {} + public function getKey(): K { return $this->key; } + public function getVal(): V { return $this->val; } +} + +// Basic generic instantiation +$box = new Box(42); +echo $box->get() . "\n"; + +// Type enforcement +try { + $box2 = new Box("hello"); +} catch (TypeError $e) { + echo "TypeError: OK\n"; +} + +// Default type parameters +$pair = new Pair(42, "age"); +echo $pair->getKey() . "\n"; +echo $pair->getVal() . "\n"; + +// Inheritance with bound generic args +class IntBox extends Box {} +$ib = new IntBox(99); +echo $ib->get() . "\n"; + +// Wildcard types +function acceptAny(Box $b): void { + echo "Any: OK\n"; +} +acceptAny($box); +acceptAny(new Box("hi")); + +// Static method call with generics +class Factory { + public static function create(T $value): T { + return $value; + } +} +echo Factory::create(123) . "\n"; + +// var_dump display +var_dump($box); + +echo "Done.\n"; +?> +--EXPECTF-- +42 +TypeError: OK +42 +age +99 +Any: OK +Any: OK +123 +object(Box)#%d (1) { + ["value":"Box":private]=> + int(42) +} +Done. diff --git a/Zend/tests/generics/generic_jit.phpt b/Zend/tests/generics/generic_jit.phpt new file mode 100644 index 0000000000000..3ccb5d60749ae --- /dev/null +++ b/Zend/tests/generics/generic_jit.phpt @@ -0,0 +1,58 @@ +--TEST-- +Generic classes work with JIT enabled +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.jit=1255 +opcache.jit_buffer_size=64M +--FILE-- + { + private T $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +// Basic generic instantiation +$box = new Box(42); +echo $box->get() . "\n"; + +// Type enforcement +try { + $box2 = new Box("hello"); +} catch (TypeError $e) { + echo "TypeError: OK\n"; +} + +// Return type enforcement +class Container { + private T $item; + public function __construct(T $item) { $this->item = $item; } + public function getItem(): T { return $this->item; } +} + +$c = new Container("world"); +echo $c->getItem() . "\n"; + +// Multiple calls to trigger JIT compilation +for ($i = 0; $i < 100; $i++) { + $b = new Box($i); + $b->get(); +} +echo "Hot loop: OK\n"; + +// Inheritance with bound generic args +class IntBox extends Box {} +$ib = new IntBox(99); +echo $ib->get() . "\n"; + +echo "Done.\n"; +?> +--EXPECTF-- +42 +TypeError: OK +world +Hot loop: OK +99 +Done. diff --git a/Zend/tests/generics/generic_opcache.phpt b/Zend/tests/generics/generic_opcache.phpt new file mode 100644 index 0000000000000..a04c3aa7d6a29 --- /dev/null +++ b/Zend/tests/generics/generic_opcache.phpt @@ -0,0 +1,66 @@ +--TEST-- +Generic classes work with opcache enabled +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +--FILE-- + { + private T $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +class Pair { + public function __construct(private K $key, private V $val) {} + public function getKey(): K { return $this->key; } + public function getVal(): V { return $this->val; } +} + +// Basic generic instantiation +$box = new Box(42); +echo $box->get() . "\n"; + +// Type enforcement +try { + $box2 = new Box("hello"); +} catch (TypeError $e) { + echo "TypeError: OK\n"; +} + +// Default type parameters +$pair = new Pair(42, "age"); +echo $pair->getKey() . "\n"; +echo $pair->getVal() . "\n"; + +// Inheritance with bound generic args +class IntBox extends Box {} +$ib = new IntBox(99); +echo $ib->get() . "\n"; + +// Wildcard types +function acceptAny(Box $b): void { + echo "Any: OK\n"; +} +acceptAny($box); +acceptAny(new Box("hi")); + +// var_dump display +var_dump($box); + +echo "Done.\n"; +?> +--EXPECTF-- +42 +TypeError: OK +42 +age +99 +Any: OK +Any: OK +object(Box)#%d (1) { + ["value":"Box":private]=> + int(42) +} +Done. diff --git a/Zend/tests/generics/generic_reject_never_extends.phpt b/Zend/tests/generics/generic_reject_never_extends.phpt new file mode 100644 index 0000000000000..5172d23c39a7c --- /dev/null +++ b/Zend/tests/generics/generic_reject_never_extends.phpt @@ -0,0 +1,11 @@ +--TEST-- +Generic class: reject never as generic type argument in extends +--FILE-- + { + public function __construct(public T $value) {} +} +class NeverBox extends Box {} +?> +--EXPECTF-- +Fatal error: never cannot be used as a generic type argument in %s on line %d diff --git a/Zend/tests/generics/generic_reject_never_new.phpt b/Zend/tests/generics/generic_reject_never_new.phpt new file mode 100644 index 0000000000000..38e2065586cec --- /dev/null +++ b/Zend/tests/generics/generic_reject_never_new.phpt @@ -0,0 +1,11 @@ +--TEST-- +Generic class: reject never as generic type argument in new +--FILE-- + { + public function __construct(public T $value) {} +} +$b = new Box(42); +?> +--EXPECTF-- +Fatal error: never cannot be used as a generic type argument in %s on line %d diff --git a/Zend/tests/generics/generic_reject_void_extends.phpt b/Zend/tests/generics/generic_reject_void_extends.phpt new file mode 100644 index 0000000000000..39c030bacae2b --- /dev/null +++ b/Zend/tests/generics/generic_reject_void_extends.phpt @@ -0,0 +1,11 @@ +--TEST-- +Generic class: reject void as generic type argument in extends +--FILE-- + { + public function __construct(public T $value) {} +} +class VoidBox extends Box {} +?> +--EXPECTF-- +Fatal error: void cannot be used as a generic type argument in %s on line %d diff --git a/Zend/tests/generics/generic_reject_void_new.phpt b/Zend/tests/generics/generic_reject_void_new.phpt new file mode 100644 index 0000000000000..0e3eda4df1ee8 --- /dev/null +++ b/Zend/tests/generics/generic_reject_void_new.phpt @@ -0,0 +1,11 @@ +--TEST-- +Generic class: reject void as generic type argument in new +--FILE-- + { + public function __construct(public T $value) {} +} +$b = new Box(42); +?> +--EXPECTF-- +Fatal error: void cannot be used as a generic type argument in %s on line %d diff --git a/Zend/tests/generics/generic_resolved_masks_complex.phpt b/Zend/tests/generics/generic_resolved_masks_complex.phpt new file mode 100644 index 0000000000000..5de9487012c7c --- /dev/null +++ b/Zend/tests/generics/generic_resolved_masks_complex.phpt @@ -0,0 +1,90 @@ +--TEST-- +Generic class: resolved_masks slow path for complex types (generic class refs, nested) +--DESCRIPTION-- +Tests that the resolved_masks optimization correctly falls through to the +slow path for complex types like generic class references (Box), +class types, and nested generics. The mask is 0 for these, forcing +the full type check. +--FILE-- + { + public T $value; + public function __construct(T $value) { $this->value = $value; } + public function get(): T { return $this->value; } +} + +// Generic class ref as type arg: Box> +// resolved_masks[0] should be 0 (complex type), falling through to slow path +$inner = new Box(42); +$outer = new Box>($inner); +echo "nested create: OK\n"; + +// Method return with nested generic +echo $outer->get()->get() . "\n"; + +// Property access on nested generic +echo $outer->value->value . "\n"; + +// Constructor type check (slow path: verifies Box arg matches T=Box) +try { + $bad = new Box>("not a box"); +} catch (TypeError $e) { + echo "nested ctor reject: OK\n"; +} + +// Wrong inner type +$wrongInner = new Box("hello"); +try { + $bad2 = new Box>($wrongInner); +} catch (TypeError $e) { + echo "wrong inner type reject: OK\n"; +} + +// Property assignment on nested generic (triggers slow path type check) +try { + $outer->get()->value = "not an int"; +} catch (TypeError $e) { + echo "nested prop reject: OK\n"; +} + +// Valid property assignment on inner +$outer->get()->value = 100; +echo $outer->get()->value . "\n"; + +// Class type arg (non-generic class) +interface Printable { + public function display(): string; +} + +class Label implements Printable { + public function __construct(private string $text) {} + public function display(): string { return $this->text; } +} + +class Wrapper { + public function __construct(private T $item) {} + public function show(): string { return $this->item->display(); } +} + +$w = new Wrapper