diff --git a/Zend/Optimizer/compact_literals.c b/Zend/Optimizer/compact_literals.c index 01eb37d7081bb..7d1d0406bb7f3 100644 --- a/Zend/Optimizer/compact_literals.c +++ b/Zend/Optimizer/compact_literals.c @@ -558,6 +558,7 @@ void zend_optimizer_compact_literals(zend_op_array *op_array, zend_optimizer_ctx break; case ZEND_ASSIGN_OBJ: case ZEND_ASSIGN_OBJ_REF: + case ZEND_CLONE_INIT_PROP: case ZEND_FETCH_OBJ_R: case ZEND_FETCH_OBJ_W: case ZEND_FETCH_OBJ_RW: diff --git a/Zend/Optimizer/zend_inference.c b/Zend/Optimizer/zend_inference.c index a4aca39e2edbc..786282ec1cf6a 100644 --- a/Zend/Optimizer/zend_inference.c +++ b/Zend/Optimizer/zend_inference.c @@ -2562,7 +2562,8 @@ static zend_always_inline zend_result _zend_update_type_info( || opline->opcode == ZEND_ASSIGN_OBJ_OP || opline->opcode == ZEND_ASSIGN_STATIC_PROP_OP || opline->opcode == ZEND_ASSIGN_DIM - || opline->opcode == ZEND_ASSIGN_OBJ) + || opline->opcode == ZEND_ASSIGN_OBJ + || opline->opcode == ZEND_CLONE_INIT_PROP) && !(OP1_DATA_INFO() & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_CLASS)) /*&& 0*/)) { tmp = 0; if (ssa_op->result_def >= 0 && !(ssa_var_info[ssa_op->result_def].type & MAY_BE_REF)) { @@ -2578,7 +2579,8 @@ static zend_always_inline zend_result _zend_update_type_info( || opline->opcode == ZEND_ASSIGN_OBJ_OP || opline->opcode == ZEND_ASSIGN_STATIC_PROP_OP || opline->opcode == ZEND_ASSIGN_DIM - || opline->opcode == ZEND_ASSIGN_OBJ) { + || opline->opcode == ZEND_ASSIGN_OBJ + || opline->opcode == ZEND_CLONE_INIT_PROP) { if ((ssa_op+1)->op1_def >= 0 && !(ssa_var_info[(ssa_op+1)->op1_def].type & MAY_BE_REF)) { UPDATE_SSA_TYPE(tmp, (ssa_op+1)->op1_def); } @@ -3028,6 +3030,7 @@ static zend_always_inline zend_result _zend_update_type_info( } break; case ZEND_ASSIGN_OBJ: + case ZEND_CLONE_INIT_PROP: if (opline->op1_type == IS_CV) { zend_class_entry *ce = ssa_var_info[ssa_op->op1_use].ce; bool add_rc = (t1 & (MAY_BE_OBJECT|MAY_BE_REF)) && (!ce @@ -3695,6 +3698,7 @@ static zend_always_inline zend_result _zend_update_type_info( case ZEND_ASSIGN_OBJ: case ZEND_ASSIGN_OBJ_OP: case ZEND_ASSIGN_OBJ_REF: + case ZEND_CLONE_INIT_PROP: case ZEND_PRE_INC_OBJ: case ZEND_PRE_DEC_OBJ: case ZEND_POST_INC_OBJ: @@ -5237,6 +5241,41 @@ ZEND_API bool zend_may_throw_ex(const zend_op *opline, const zend_ssa_op *ssa_op } } return 1; + case ZEND_CLONE_INIT_PROP: + if (t1 & (MAY_BE_ANY-MAY_BE_OBJECT)) { + return 1; + } + if (ssa_op->op1_use) { + zend_ssa_var_info *var_info = ssa->var_info + ssa_op->op1_use; + zend_class_entry *ce = var_info->ce; + + if (var_info->is_instanceof || + !ce || ce->create_object || ce->__get || ce->__set || ce->parent) { + return 1; + } + + if (opline->op2_type != IS_CONST) { + return 1; + } + + zend_string *prop_name = Z_STR_P(CRT_CONSTANT(opline->op2)); + if (ZSTR_LEN(prop_name) > 0 && ZSTR_VAL(prop_name)[0] == '\0') { + return 1; + } + + zend_property_info *prop_info = + zend_hash_find_ptr(&ce->properties_info, prop_name); + if (prop_info) { + if (ZEND_TYPE_IS_SET(prop_info->type)) { + return 1; + } + return !(prop_info->flags & ZEND_ACC_PUBLIC) + && prop_info->ce != op_array->scope; + } else { + return !(ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES); + } + } + return 1; case ZEND_ROPE_INIT: case ZEND_ROPE_ADD: case ZEND_ROPE_END: diff --git a/Zend/Optimizer/zend_optimizer.c b/Zend/Optimizer/zend_optimizer.c index 3738e058cd881..9adcc536cb466 100644 --- a/Zend/Optimizer/zend_optimizer.c +++ b/Zend/Optimizer/zend_optimizer.c @@ -533,6 +533,7 @@ bool zend_optimizer_update_op2_const(zend_op_array *op_array, break; case ZEND_ASSIGN_OBJ: case ZEND_ASSIGN_OBJ_REF: + case ZEND_CLONE_INIT_PROP: case ZEND_FETCH_OBJ_R: case ZEND_FETCH_OBJ_W: case ZEND_FETCH_OBJ_RW: diff --git a/Zend/Optimizer/zend_ssa.c b/Zend/Optimizer/zend_ssa.c index 4c09e5e105b50..16882b76ee498 100644 --- a/Zend/Optimizer/zend_ssa.c +++ b/Zend/Optimizer/zend_ssa.c @@ -588,6 +588,7 @@ static zend_always_inline int _zend_ssa_rename_op(const zend_op_array *op_array, break; case ZEND_ASSIGN_DIM: case ZEND_ASSIGN_OBJ: + case ZEND_CLONE_INIT_PROP: next = opline + 1; if (next->op1_type & (IS_CV|IS_VAR|IS_TMP_VAR)) { ssa_ops[k + 1].op1_use = var[EX_VAR_TO_NUM(next->op1.var)]; diff --git a/Zend/tests/clone_initializer/clone_initializer_error1.phpt b/Zend/tests/clone_initializer/clone_initializer_error1.phpt new file mode 100644 index 0000000000000..a4edc54fd8a8f --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error1.phpt @@ -0,0 +1,16 @@ +--TEST-- +Test that the property initializer list is required when "with" is given +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token ";", expecting "[" in %s on line %d diff --git a/Zend/tests/clone_initializer/clone_initializer_error10.phpt b/Zend/tests/clone_initializer/clone_initializer_error10.phpt new file mode 100644 index 0000000000000..547d9c9b96b14 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error10.phpt @@ -0,0 +1,32 @@ +--TEST-- +Test that clone with cannot be used on public readonly properties from outside the class. +--FILE-- + 1]; +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +try { + $foo2 = clone $foo1 with ["baz" => 1]; +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +?> +--EXPECT-- +Cannot modify readonly property Foo::$bar from global scope +Cannot initialize readonly property Foo::$baz from global scope diff --git a/Zend/tests/clone_initializer/clone_initializer_error11.phpt b/Zend/tests/clone_initializer/clone_initializer_error11.phpt new file mode 100644 index 0000000000000..9cbe6ac5e7c7c --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error11.phpt @@ -0,0 +1,38 @@ +--TEST-- +Test that the destructor of the cloned object is run +--FILE-- +bar\n"; + } + + public function with() + { + return clone $this with [ + "bar" => 1, + "bar" => 2, + ]; + } +} + +$foo = new Foo(0); + +try { + $foo->with(); +} catch (Error $e) { + echo $e->getMessage() . "\n"; +} + +?> +--EXPECTF-- +Destruct 1 +Cannot modify readonly property Foo::$bar +Destruct 0 diff --git a/Zend/tests/clone_initializer/clone_initializer_error2.phpt b/Zend/tests/clone_initializer/clone_initializer_error2.phpt new file mode 100644 index 0000000000000..5ed5828f7a42d --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error2.phpt @@ -0,0 +1,16 @@ +--TEST-- +Test that the property initializer list cannot contain invalid identifiers when using the : syntax +--FILE-- + +--EXPECTF-- +Parse error: syntax error, unexpected token ":" in %s on line %d diff --git a/Zend/tests/clone_initializer/clone_initializer_error3.phpt b/Zend/tests/clone_initializer/clone_initializer_error3.phpt new file mode 100644 index 0000000000000..5fae0f6bf7411 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error3.phpt @@ -0,0 +1,21 @@ +--TEST-- +Test that the clone property initializer respects visibility +--FILE-- + 1]; +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +?> +--EXPECT-- +Cannot access private property Foo::$bar diff --git a/Zend/tests/clone_initializer/clone_initializer_error4.phpt b/Zend/tests/clone_initializer/clone_initializer_error4.phpt new file mode 100644 index 0000000000000..d8a696b0cdbd4 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error4.phpt @@ -0,0 +1,38 @@ +--TEST-- +Test that readonly properties cannot be assigned in "clone with" multiple times +--FILE-- + 1, + "bar" => 2, + ]; + } +} + +$foo = new Foo(0); + +try { + $foo->with(); +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +try { + $foo->with(); +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +?> +--EXPECT-- +Cannot modify readonly property Foo::$bar +Cannot modify readonly property Foo::$bar diff --git a/Zend/tests/clone_initializer/clone_initializer_error5.phpt b/Zend/tests/clone_initializer/clone_initializer_error5.phpt new file mode 100644 index 0000000000000..2488ddb71bc30 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error5.phpt @@ -0,0 +1,31 @@ +--TEST-- +Test TypeError when "cloning with" non-readonly property +--FILE-- + []]; +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone $obj1 with ["bar" => []]; // The same as above but now using cache slots +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +var_dump($obj1->bar); + +?> +--EXPECT-- +Cannot assign array to property Foo::$bar of type int +Cannot assign array to property Foo::$bar of type int +int(1) diff --git a/Zend/tests/clone_initializer/clone_initializer_error6.phpt b/Zend/tests/clone_initializer/clone_initializer_error6.phpt new file mode 100644 index 0000000000000..5e598c7f53538 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error6.phpt @@ -0,0 +1,34 @@ +--TEST-- +Test "clone with" with a declared untyped property of an object throwing an exception in the destructor +--FILE-- + new stdClass()]; +} catch (Exception $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone returnFoo() with ["bar" => new stdClass()]; // The same as above but now using cache slots +} catch (Exception $e) { + echo $e->getMessage() . "\n"; +} + +?> +--EXPECT-- +Error in destructor +Error in destructor diff --git a/Zend/tests/clone_initializer/clone_initializer_error7.phpt b/Zend/tests/clone_initializer/clone_initializer_error7.phpt new file mode 100644 index 0000000000000..deed5a53c4867 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error7.phpt @@ -0,0 +1,33 @@ +--TEST-- +Test "clone with" with dynamic properties of an object throwing an exception in the destructor +--FILE-- + new stdClass()]; +} catch (Exception $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone returnFoo() with ["bar" => new stdClass()]; // The same as above but now using cache slots +} catch (Exception $e) { + echo $e->getMessage() . "\n"; +} + +?> +--EXPECT-- +Error in destructor +Error in destructor diff --git a/Zend/tests/clone_initializer/clone_initializer_error8.phpt b/Zend/tests/clone_initializer/clone_initializer_error8.phpt new file mode 100644 index 0000000000000..0af06f7b3f39d --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error8.phpt @@ -0,0 +1,66 @@ +--TEST-- +Test "clone with" with invalid property names +--FILE-- + 1]; +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone new stdClass() with [$undefined => 1]; // The same as above but now using cache slots +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone new stdClass() with [null => 1]; +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone new stdClass() with [null => 1]; // The same as above but now using cache slots +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone new stdClass() with [[] => 1]; +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone new stdClass() with [[] => 1]; // The same as above but now using cache slots +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone new stdClass() with [1 => 1]; +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +try { + clone new stdClass() with [1 => 1]; // The same as above but now using cache slots +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +?> +--EXPECTF-- +Warning: Undefined variable $undefined in %s on line %d +Property name must be of type string, null given + +Warning: Undefined variable $undefined in %s on line %d +Property name must be of type string, null given +Property name must be of type string, null given +Property name must be of type string, null given +Property name must be of type string, array given +Property name must be of type string, array given +Property name must be of type string, int given +Property name must be of type string, int given diff --git a/Zend/tests/clone_initializer/clone_initializer_error9.phpt b/Zend/tests/clone_initializer/clone_initializer_error9.phpt new file mode 100644 index 0000000000000..c92524a348730 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_error9.phpt @@ -0,0 +1,67 @@ +--TEST-- +Test that readonly properties cannot be assigned after "clone with" +--FILE-- + 1, + ]; + } + + public function assign() + { + $this->bar = 2; + } +} + +$foo1 = new Foo(0); + +$foo2 = $foo1->with(); + +try { + $foo1->assign(); +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +try { + $foo2->assign(); +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +$foo3 = $foo2->with(); // The same as above, but now using cache slots + +try { + $foo1->assign(); // The same as above, but now using cache slots +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +try { + $foo2->assign(); // The same as above, but now using cache slots +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +try { + $foo3->assign(); // The same as above, but now using cache slots +} catch (Error $exception) { + echo $exception->getMessage() . "\n"; +} + +?> +--EXPECT-- +Cannot modify readonly property Foo::$bar +Cannot modify readonly property Foo::$bar +Cannot modify readonly property Foo::$bar +Cannot modify readonly property Foo::$bar +Cannot modify readonly property Foo::$bar diff --git a/Zend/tests/clone_initializer/clone_initializer_success1.phpt b/Zend/tests/clone_initializer/clone_initializer_success1.phpt new file mode 100644 index 0000000000000..225298e47ae34 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success1.phpt @@ -0,0 +1,47 @@ +--TEST-- +Test that declared properties can be initialized during cloning +--FILE-- + $property1, + "property2" => $property2, + ]; + } +} + +$obj1 = new Foo(); +$obj2 = $obj1->withProperties(1, "foo"); +$obj3 = $obj2->withProperties(2, "bar"); // The same as above but now using cache slots + +var_dump($obj1); +var_dump($obj2); +var_dump($obj3); + +?> +--EXPECTF-- +object(Foo)#1 (%d) { + ["property1"]=> + uninitialized(int) + ["property2"]=> + uninitialized(string) +} +object(Foo)#2 (%d) { + ["property1"]=> + int(1) + ["property2"]=> + string(3) "foo" +} +object(Foo)#3 (%d) { + ["property1"]=> + int(2) + ["property2"]=> + string(3) "bar" +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success10.phpt b/Zend/tests/clone_initializer/clone_initializer_success10.phpt new file mode 100644 index 0000000000000..9efd4e715425b --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success10.phpt @@ -0,0 +1,31 @@ +--TEST-- +Test that clone initializer list is displayed properly in assert() +--INI-- +zend.assertions = 1 +assert.exception = 1 +--FILE-- +getMessage() . "\n"; +} + +try { + assert(clone new stdClass() with [] === null); +} catch (AssertionError $e) { + echo $e->getMessage() . "\n"; +} + +try { + assert(clone new stdClass() with ["foo" => 1, "bar" => "abc"] === null); +} catch (AssertionError $e) { + echo $e->getMessage() . "\n"; +} + +?> +--EXPECT-- +assert(clone new stdClass() === null) +assert(clone new stdClass() with [] === null) +assert(clone new stdClass() with ['foo' => 1, 'bar' => 'abc'] === null) diff --git a/Zend/tests/clone_initializer/clone_initializer_success11.phpt b/Zend/tests/clone_initializer/clone_initializer_success11.phpt new file mode 100644 index 0000000000000..9498cb5bbbebe --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success11.phpt @@ -0,0 +1,100 @@ +--TEST-- +Test that the property initializer list can contain expressions +--FILE-- + "value"]; + } + + public function withProperty2() + { + $property = "string"; + + return clone $this with [$this->getProperty1Name() => "value"]; + } + + public function withProperty3() + { + $property = "property2"; + + return clone $this with [$property => "value"]; + } + + public function withProperty4() + { + return clone $this with [substr($this->getProperty1Name(), 0, 8) . "1" => "value"]; + } + + private function getProperty1Name() { + return "property1"; + } +} + +$obj = new Foo(); +$obj1 = $obj->withProperty1(); +$obj2 = $obj->withProperty1(); +$obj3 = $obj->withProperty2(); +$obj4 = $obj->withProperty2(); +$obj5 = $obj->withProperty3(); +$obj6 = $obj->withProperty3(); +$obj7 = $obj->withProperty4(); +$obj8 = $obj->withProperty4(); + +var_dump($obj1); +var_dump($obj2); +var_dump($obj3); +var_dump($obj4); +var_dump($obj5); +var_dump($obj6); +var_dump($obj7); +var_dump($obj8); + +?> +--EXPECTF-- +Deprecated: Creation of dynamic property Foo::$property2 is deprecated in %s on line %d + +Deprecated: Creation of dynamic property Foo::$property2 is deprecated in %s on line %d +object(Foo)#%d (%d) { + ["property1":"Foo":private]=> + string(5) "value" +} +object(Foo)#%d (%d) { + ["property1":"Foo":private]=> + string(5) "value" +} +object(Foo)#%d (%d) { + ["property1":"Foo":private]=> + string(5) "value" +} +object(Foo)#%d (%d) { + ["property1":"Foo":private]=> + string(5) "value" +} +object(Foo)#%d (%d) { + ["property1":"Foo":private]=> + NULL + ["property2"]=> + string(5) "value" +} +object(Foo)#%d (%d) { + ["property1":"Foo":private]=> + NULL + ["property2"]=> + string(5) "value" +} +object(Foo)#%d (%d) { + ["property1":"Foo":private]=> + string(5) "value" +} +object(Foo)#%d (%d) { + ["property1":"Foo":private]=> + string(5) "value" +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success12.phpt b/Zend/tests/clone_initializer/clone_initializer_success12.phpt new file mode 100644 index 0000000000000..66aa36e5b9db4 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success12.phpt @@ -0,0 +1,31 @@ +--TEST-- +Test that non-readonly properties can be assigned in "cloned with" multiple times +--FILE-- + 1, + "bar" => 2, + "bar" => 3, + ]; + } +} + +$foo = new Foo(0); + +var_dump($foo->with()); + +?> +--EXPECTF-- +object(Foo)#%d (%d) { + ["bar"]=> + int(3) +} \ No newline at end of file diff --git a/Zend/tests/clone_initializer/clone_initializer_success13.phpt b/Zend/tests/clone_initializer/clone_initializer_success13.phpt new file mode 100644 index 0000000000000..73403c0a49e31 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success13.phpt @@ -0,0 +1,29 @@ +--TEST-- +Test that properties can be assigned in "cloned with" by referencing them via a string literal expression +--FILE-- + 1, + ]; + } +} + +$foo = new Foo(0); + +var_dump($foo->with()); + +?> +--EXPECTF-- +object(Foo)#%d (%d) { + ["bar"]=> + int(1) +} \ No newline at end of file diff --git a/Zend/tests/clone_initializer/clone_initializer_success14.phpt b/Zend/tests/clone_initializer/clone_initializer_success14.phpt new file mode 100644 index 0000000000000..5933348da4ca8 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success14.phpt @@ -0,0 +1,34 @@ +--TEST-- +Test that readonly properties can be assigned in "cloned with" even if they were assigned in the __clone() method +--FILE-- +bar = 1; + } + + public function with() + { + return clone $this with [ + "bar" => 2, + ]; + } +} + +$foo = new Foo(0); + +var_dump($foo->with()); + +?> +--EXPECTF-- +object(Foo)#%d (%d) { + ["bar"]=> + int(2) +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success15.phpt b/Zend/tests/clone_initializer/clone_initializer_success15.phpt new file mode 100644 index 0000000000000..405a881c0d959 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success15.phpt @@ -0,0 +1,20 @@ +--TEST-- +Test that "with" is a semi-reserved keyword +--FILE-- + +--EXPECT-- diff --git a/Zend/tests/clone_initializer/clone_initializer_success16.phpt b/Zend/tests/clone_initializer/clone_initializer_success16.phpt new file mode 100644 index 0000000000000..93d29332400f8 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success16.phpt @@ -0,0 +1,53 @@ +--TEST-- +Test that using "clone with" with deep cloned properties will result in the property to be cloned twice +--FILE-- +bar = clone $this->bar; + } + + public function withBar(): static + { + return clone $this with [ + "bar" => new Bar(2), + ]; + } +} + +$foo = new Foo(new Bar(1)); + +var_dump($foo->withBar()); + +?> +--EXPECTF-- +Cloning Foo +Cloning Bar +object(Foo)#3 (1) { + ["bar"]=> + object(Bar)#5 (1) { + ["baz":"Bar":private]=> + int(2) + } +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success2.phpt b/Zend/tests/clone_initializer/clone_initializer_success2.phpt new file mode 100644 index 0000000000000..c1536a491e885 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success2.phpt @@ -0,0 +1,43 @@ +--TEST-- +Test that dynamic properties can be initialized during cloning +--FILE-- + $property1, + "property2" => $property2, + ]; + } +} + +$obj1 = new Foo(); +$obj2 = $obj1->withProperties(1, false); +$obj3 = $obj2->withProperties(2, true); // The same as above but now using cache slots + +var_dump($obj1); +var_dump($obj2); +var_dump($obj3); + +?> +--EXPECTF-- +Deprecated: Creation of dynamic property Foo::$property1 is deprecated in %s on line %d + +Deprecated: Creation of dynamic property Foo::$property2 is deprecated in %s on line %d +object(Foo)#1 (%d) { +} +object(Foo)#2 (%d) { + ["property1"]=> + int(1) + ["property2"]=> + bool(false) +} +object(Foo)#3 (%d) { + ["property1"]=> + int(2) + ["property2"]=> + bool(true) +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success3.phpt b/Zend/tests/clone_initializer/clone_initializer_success3.phpt new file mode 100644 index 0000000000000..73753c99e3532 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success3.phpt @@ -0,0 +1,24 @@ +--TEST-- +Test that the property initializer list can be empty +--FILE-- +withProperties(); +var_dump($bar); + +?> +--EXPECT-- +object(Foo)#1 (0) { +} +object(Foo)#2 (0) { +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success4.phpt b/Zend/tests/clone_initializer/clone_initializer_success4.phpt new file mode 100644 index 0000000000000..b83c2f4d4a885 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success4.phpt @@ -0,0 +1,27 @@ +--TEST-- +Test that "clone with" is still chainable +--FILE-- +bar; + } +} + +$foo = new Foo(); +var_dump($foo); +$bar = $foo->withProperties(); +var_dump($bar); + +?> +--EXPECT-- +object(Foo)#1 (1) { + ["bar"]=> + int(1) +} +int(1) diff --git a/Zend/tests/clone_initializer/clone_initializer_success5.phpt b/Zend/tests/clone_initializer/clone_initializer_success5.phpt new file mode 100644 index 0000000000000..60e2ddaea4e65 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success5.phpt @@ -0,0 +1,30 @@ +--TEST-- +Test that the "clone with" respects #[AllowDynamicProperties] +--FILE-- + 1, "bar" => ""]; +$obj3 = clone $obj1 with ["foo" => 2, "bar" => []]; + +var_dump($obj1); +var_dump($obj2); +var_dump($obj3); + +?> +--EXPECTF-- +object(stdClass)#1 (%d) { +} +object(stdClass)#2 (%d) { + ["foo"]=> + int(1) + ["bar"]=> + string(0) "" +} +object(stdClass)#3 (%d) { + ["foo"]=> + int(2) + ["bar"]=> + array(0) { + } +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success6.phpt b/Zend/tests/clone_initializer/clone_initializer_success6.phpt new file mode 100644 index 0000000000000..32f5e03d28650 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success6.phpt @@ -0,0 +1,46 @@ +--TEST-- +Test that "clone with" works with untyped properties +--FILE-- + new stdClass(), "baz" => strpos("abc", "b")]; +$obj3 = clone $obj2 with ["bar" => new stdClass(), "baz" => ["abc", "def"]]; // The same as above but now using cache slots + +var_dump($obj1); +var_dump($obj2); +var_dump($obj3); + +?> +--EXPECTF-- +object(Foo)#1 (%d) { + ["bar"]=> + NULL + ["baz"]=> + NULL +} +object(Foo)#2 (%d) { + ["bar"]=> + object(stdClass)#3 (0) { + } + ["baz"]=> + int(1) +} +object(Foo)#4 (%d) { + ["bar"]=> + object(stdClass)#5 (0) { + } + ["baz"]=> + array(2) { + [0]=> + string(3) "abc" + [1]=> + string(3) "def" + } +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success7.phpt b/Zend/tests/clone_initializer/clone_initializer_success7.phpt new file mode 100644 index 0000000000000..58ba46699cb5a --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success7.phpt @@ -0,0 +1,20 @@ +--TEST-- +Test that "clone with" works with expressions as clone operand +--FILE-- + +--EXPECT-- +object(Foo)#2 (0) { +} diff --git a/Zend/tests/clone_initializer/clone_initializer_success8.phpt b/Zend/tests/clone_initializer/clone_initializer_success8.phpt new file mode 100644 index 0000000000000..8d36d38f0dd0f --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success8.phpt @@ -0,0 +1,25 @@ +--TEST-- +Test that "clone with" works with a reference clone operand +--FILE-- + 1, "property2" => 2]; +var_dump($bar); + +?> +--EXPECTF-- +object(Foo)#2 (%d) { + ["property1"]=> + int(1) + ["property2"]=> + int(2) +} \ No newline at end of file diff --git a/Zend/tests/clone_initializer/clone_initializer_success9.phpt b/Zend/tests/clone_initializer/clone_initializer_success9.phpt new file mode 100644 index 0000000000000..8898a423d2a69 --- /dev/null +++ b/Zend/tests/clone_initializer/clone_initializer_success9.phpt @@ -0,0 +1,54 @@ +--TEST-- +Test that "clone with" works with readonly properties +--FILE-- + $bar, + "baz" => $baz, + ]; + } +} + +$stdClass = new stdClass(); + +$obj1 = new Foo(0, $stdClass); +$obj2 = $obj1->with(1, $stdClass); +$obj3 = $obj2->with(2, new stdClass()); // The same as above but now using cache slots + +var_dump($obj1); +var_dump($obj2); +var_dump($obj3); + +?> +--EXPECTF-- +object(Foo)#2 (%d) { + ["bar"]=> + int(0) + ["baz"]=> + object(stdClass)#1 (%d) { + } +} +object(Foo)#3 (%d) { + ["bar"]=> + int(1) + ["baz"]=> + object(stdClass)#1 (%d) { + } +} +object(Foo)#5 (%d) { + ["bar"]=> + int(2) + ["baz"]=> + object(stdClass)#4 (%d) { + } +} diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c index 525d9dfe9a742..331498c685b82 100644 --- a/Zend/zend_ast.c +++ b/Zend/zend_ast.c @@ -1883,6 +1883,17 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio case ZEND_AST_MATCH_ARM_LIST: zend_ast_export_list(str, (zend_ast_list*)ast, 0, 0, indent); break; + case ZEND_AST_PROPERTY_INITIALIZER_LIST: + smart_str_appends(str, "["); + zend_ast_export_list(str, (zend_ast_list*)ast, 1, 0, indent); + smart_str_appends(str, "]"); + break; + case ZEND_AST_INITIALIZER_EXPR: { + zend_ast_export_ex(str, ast->child[0], 0, indent); + smart_str_appends(str, " => "); + zend_ast_export_ex(str, ast->child[1], priority, indent); + break; + } case ZEND_AST_CLOSURE_USES: smart_str_appends(str, " use("); zend_ast_export_var_list(str, (zend_ast_list*)ast, indent); @@ -2013,8 +2024,6 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio } smart_str_appendc(str, '`'); break; - case ZEND_AST_CLONE: - PREFIX_OP("clone ", 270, 271); case ZEND_AST_EXIT: if (ast->child[0]) { FUNC_OP("exit"); @@ -2210,6 +2219,16 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio smart_str_appendc(str, ')'); } break; + case ZEND_AST_CLONE: + if (ast->child[1]) { + smart_str_appends(str, "clone "); + zend_ast_export_ex(str, ast->child[0], priority, indent); + smart_str_appends(str, " with "); + zend_ast_export_ex(str, ast->child[1], priority, indent); + } else { + PREFIX_OP("clone ", 270, 271); + } + break; case ZEND_AST_INSTANCEOF: zend_ast_export_ex(str, ast->child[0], 0, indent); smart_str_appends(str, " instanceof "); diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h index 963b81e533084..7fc27f75c53e1 100644 --- a/Zend/zend_ast.h +++ b/Zend/zend_ast.h @@ -67,6 +67,7 @@ enum _zend_ast_kind { ZEND_AST_ATTRIBUTE_GROUP, ZEND_AST_MATCH_ARM_LIST, ZEND_AST_MODIFIER_LIST, + ZEND_AST_PROPERTY_INITIALIZER_LIST, /* 0 child nodes */ ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT, @@ -85,7 +86,6 @@ enum _zend_ast_kind { ZEND_AST_ISSET, ZEND_AST_SILENCE, ZEND_AST_SHELL_EXEC, - ZEND_AST_CLONE, ZEND_AST_EXIT, ZEND_AST_PRINT, ZEND_AST_INCLUDE_OR_EVAL, @@ -116,6 +116,7 @@ enum _zend_ast_kind { ZEND_AST_STATIC_PROP, ZEND_AST_CALL, ZEND_AST_CLASS_CONST, + ZEND_AST_CLONE, ZEND_AST_ASSIGN, ZEND_AST_ASSIGN_REF, ZEND_AST_ASSIGN_OP, @@ -149,6 +150,7 @@ enum _zend_ast_kind { ZEND_AST_MATCH, ZEND_AST_MATCH_ARM, ZEND_AST_NAMED_ARG, + ZEND_AST_INITIALIZER_EXPR, /* 3 child nodes */ ZEND_AST_METHOD_CALL = 3 << ZEND_AST_NUM_CHILDREN_SHIFT, diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c index 4077ef4ef080a..2513cf49453a6 100644 --- a/Zend/zend_compile.c +++ b/Zend/zend_compile.c @@ -5050,11 +5050,46 @@ static void zend_compile_new(znode *result, zend_ast *ast) /* {{{ */ static void zend_compile_clone(znode *result, zend_ast *ast) /* {{{ */ { zend_ast *obj_ast = ast->child[0]; + zend_ast *initializer_ast = ast->child[1]; znode obj_node; zend_compile_expr(&obj_node, obj_ast); - zend_emit_op_tmp(result, ZEND_CLONE, &obj_node, NULL); + if (!initializer_ast) { + zend_emit_op_tmp(result, ZEND_CLONE, &obj_node, NULL); + } else { + zend_op *opline = zend_emit_op(result, ZEND_CLONE, &obj_node, NULL); + + zend_ast_list *list = zend_ast_get_list(initializer_ast); + uint32_t i; + + for (i = 0; i < list->children; i++) { + zend_ast *property_init_expr_ast = list->child[i]; + ZEND_ASSERT(property_init_expr_ast->kind == ZEND_AST_INITIALIZER_EXPR); + + znode property_object_node; + property_object_node.op_type = IS_VAR; + GET_NODE(&property_object_node, opline->result); + + zend_ast *property_name_ast = property_init_expr_ast->child[0]; + znode property_name_node; + zend_compile_expr(&property_name_node, property_name_ast); + + zend_ast *property_value_ast = property_init_expr_ast->child[1]; + znode property_value_node; + zend_compile_expr(&property_value_node, property_value_ast); + + opline = zend_emit_op(result, ZEND_CLONE_INIT_PROP, &property_object_node, &property_name_node); + opline->result.var = get_temporary_variable(); + opline->extended_value = zend_alloc_cache_slots(3); + if (i < list->children - 1) { + opline->result_type = IS_TMP_VAR; + } + + zend_emit_op_data(&property_value_node); + GET_NODE(result, opline->result); + } + } } /* }}} */ diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c index 52a55d218393b..f6da1241153fd 100644 --- a/Zend/zend_execute.c +++ b/Zend/zend_execute.c @@ -1025,11 +1025,6 @@ static zend_never_inline zval* zend_assign_to_typed_prop(zend_property_info *inf { zval tmp; - if (UNEXPECTED((info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { - zend_readonly_property_modification_error(info); - return &EG(uninitialized_zval); - } - ZVAL_DEREF(value); ZVAL_COPY(&tmp, value); @@ -1038,8 +1033,6 @@ static zend_never_inline zval* zend_assign_to_typed_prop(zend_property_info *inf return &EG(uninitialized_zval); } - Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; - return zend_assign_to_variable_ex(property_val, &tmp, IS_TMP_VAR, EX_USES_STRICT_TYPES(), garbage_ptr); } diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y index 298eaf95ad055..2b213ade3f9b0 100644 --- a/Zend/zend_language_parser.y +++ b/Zend/zend_language_parser.y @@ -80,6 +80,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %precedence '~' T_INT_CAST T_DOUBLE_CAST T_STRING_CAST T_ARRAY_CAST T_OBJECT_CAST T_BOOL_CAST T_UNSET_CAST '@' %right T_POW %precedence T_CLONE +%precedence T_WITH /* Resolve danging else conflict */ %precedence T_NOELSE @@ -113,6 +114,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %token T_INSTANCEOF "'instanceof'" %token T_NEW "'new'" %token T_CLONE "'clone'" +%token T_WITH "'with'" %token T_EXIT "'exit'" %token T_IF "'if'" %token T_ELSEIF "'elseif'" @@ -277,6 +279,7 @@ static YYSIZE_T zend_yytnamerr(char*, const char*); %type attributed_statement attributed_class_statement attributed_parameter %type attribute_decl attribute attributes attribute_group namespace_declaration_name %type match match_arm_list non_empty_match_arm_list match_arm match_arm_cond_list +%type clone clone_property_initializer_list non_empty_clone_property_initializer_list clone_property_initializer_expr %type enum_declaration_statement enum_backing_type enum_case enum_case_expr %type function_name non_empty_member_modifiers @@ -307,7 +310,7 @@ reserved_non_modifiers: semi_reserved: reserved_non_modifiers - | T_STATIC | T_ABSTRACT | T_FINAL | T_PRIVATE | T_PROTECTED | T_PUBLIC | T_READONLY + | T_STATIC | T_ABSTRACT | T_FINAL | T_PRIVATE | T_PROTECTED | T_PUBLIC | T_READONLY | T_WITH ; ampersand: @@ -567,6 +570,11 @@ function_name: if (zend_lex_tstring(&zv, $1) == FAILURE) { YYABORT; } $$ = zend_ast_create_zval(&zv); } + | T_WITH { + zval zv; + if (zend_lex_tstring(&zv, $1) == FAILURE) { YYABORT; } + $$ = zend_ast_create_zval(&zv); + } ; function_declaration_statement: @@ -1143,7 +1151,7 @@ expr: { $$ = zend_ast_create(ZEND_AST_ASSIGN, $1, $3); } | variable '=' ampersand variable { $$ = zend_ast_create(ZEND_AST_ASSIGN_REF, $1, $4); } - | T_CLONE expr { $$ = zend_ast_create(ZEND_AST_CLONE, $2); } + | clone { $$ = $1; } | variable T_PLUS_EQUAL expr { $$ = zend_ast_create_assign_op(ZEND_ADD, $1, $3); } | variable T_MINUS_EQUAL expr @@ -1320,6 +1328,11 @@ function_call: if (zend_lex_tstring(&zv, $1) == FAILURE) { YYABORT; } $$ = zend_ast_create(ZEND_AST_CALL, zend_ast_create_zval(&zv), $2); } + | T_WITH argument_list { + zval zv; + if (zend_lex_tstring(&zv, $1) == FAILURE) { YYABORT; } + $$ = zend_ast_create(ZEND_AST_CALL, zend_ast_create_zval(&zv), $2); + } | class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list { $$ = zend_ast_create(ZEND_AST_STATIC_CALL, $1, $3, $4); } | variable_class_name T_PAAMAYIM_NEKUDOTAYIM member_name argument_list @@ -1600,6 +1613,24 @@ isset_variable: expr { $$ = zend_ast_create(ZEND_AST_ISSET, $1); } ; +clone: + T_CLONE expr { $$ = zend_ast_create(ZEND_AST_CLONE, $2, NULL); } + | T_CLONE expr T_WITH clone_property_initializer_list { $$ = zend_ast_create(ZEND_AST_CLONE, $2, $4); } + +clone_property_initializer_list: + '[' ']' { $$ = zend_ast_create_list(0, ZEND_AST_PROPERTY_INITIALIZER_LIST); } + | '[' non_empty_clone_property_initializer_list possible_comma ']' { $$ = $2; } +; + +non_empty_clone_property_initializer_list: + clone_property_initializer_expr { $$ = zend_ast_create_list(1, ZEND_AST_PROPERTY_INITIALIZER_LIST, $1); } + | non_empty_clone_property_initializer_list ',' clone_property_initializer_expr { $$ = zend_ast_list_add($1, $3); } +; + +clone_property_initializer_expr: + expr T_DOUBLE_ARROW expr { $$ = zend_ast_create(ZEND_AST_INITIALIZER_EXPR, $1, $3); } +; + %% /* Over-ride Bison formatting routine to give better token descriptions. diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l index 054ed7bdc1ef6..e97c94171a706 100644 --- a/Zend/zend_language_scanner.l +++ b/Zend/zend_language_scanner.l @@ -1623,6 +1623,10 @@ OPTIONAL_WHITESPACE_OR_COMMENTS ({WHITESPACE}|{MULTI_LINE_COMMENT}|{SINGLE_LINE_ RETURN_TOKEN_WITH_IDENT(T_CLONE); } +"with" { + RETURN_TOKEN_WITH_IDENT(T_WITH); +} + "var" { RETURN_TOKEN_WITH_IDENT(T_VAR); } diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c index f72cb76489abd..10f9b8112f734 100644 --- a/Zend/zend_object_handlers.c +++ b/Zend/zend_object_handlers.c @@ -821,11 +821,31 @@ ZEND_API zval *zend_std_write_property(zend_object *zobj, zend_string *name, zva Z_TRY_ADDREF_P(value); if (prop_info) { - if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(variable_ptr) & IS_PROP_REINITABLE))) { - Z_TRY_DELREF_P(value); - zend_readonly_property_modification_error(prop_info); - variable_ptr = &EG(error_zval); - goto exit; + bool is_readonly = (prop_info->flags & ZEND_ACC_READONLY); + bool is_clone_with_op = false; + + if (UNEXPECTED(is_readonly)) { + is_clone_with_op = EG(current_execute_data) && + EG(current_execute_data)->func && + ZEND_USER_CODE(EG(current_execute_data)->func->common.type) && + EG(current_execute_data)->opline && + EG(current_execute_data)->opline->opcode == ZEND_CLONE_INIT_PROP; + + if (UNEXPECTED( + (!is_clone_with_op && !(Z_PROP_FLAG_P(variable_ptr) & IS_PROP_REINITABLE)) || + (is_clone_with_op && (Z_PROP_FLAG_P(variable_ptr) & IS_PROP_REINITED)) + )) { + Z_TRY_DELREF_P(value); + zend_readonly_property_modification_error(prop_info); + variable_ptr = &EG(error_zval); + goto exit; + } + + if (UNEXPECTED(!verify_readonly_initialization_access(prop_info, zobj->ce, name, "modify"))) { + Z_TRY_DELREF_P(value); + variable_ptr = &EG(error_zval); + goto exit; + } } ZVAL_COPY_VALUE(&tmp, value); @@ -844,7 +864,12 @@ ZEND_API zval *zend_std_write_property(zend_object *zobj, zend_string *name, zva variable_ptr = &EG(error_zval); goto exit; } - Z_PROP_FLAG_P(variable_ptr) &= ~IS_PROP_REINITABLE; + if (UNEXPECTED(is_readonly && is_clone_with_op)) { + Z_PROP_FLAG_P(variable_ptr) = IS_PROP_REINITED; + } else { + Z_PROP_FLAG_P(variable_ptr) = 0; + } + value = &tmp; } diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c index af4d1f265897a..04cd1ff567599 100644 --- a/Zend/zend_objects.c +++ b/Zend/zend_objects.c @@ -195,6 +195,7 @@ ZEND_API zend_object* ZEND_FASTCALL zend_objects_new(zend_class_entry *ce) ZEND_API void ZEND_FASTCALL zend_objects_clone_members(zend_object *new_object, zend_object *old_object) { bool has_clone_method = old_object->ce->clone != NULL; + bool has_readonly_props = ZEND_CLASS_HAS_READONLY_PROPS(new_object->ce); if (old_object->ce->default_properties_count) { zval *src = old_object->properties_table; @@ -209,6 +210,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_clone_members(zend_object *new_object, /* Unconditionally add the IS_PROP_REINITABLE flag to avoid a potential cache miss of property_info */ Z_PROP_FLAG_P(dst) |= IS_PROP_REINITABLE; } + Z_PROP_FLAG_P(dst) &= ~IS_PROP_REINITED; if (UNEXPECTED(Z_ISREF_P(dst)) && (ZEND_DEBUG || ZEND_REF_HAS_TYPE_SOURCES(Z_REF_P(dst)))) { @@ -220,7 +222,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_clone_members(zend_object *new_object, src++; dst++; } while (src != end); - } else if (old_object->properties && !has_clone_method) { + } else if (old_object->properties && !has_clone_method && !has_readonly_props) { /* fast copy */ if (EXPECTED(old_object->handlers == &std_object_handlers)) { if (EXPECTED(!(GC_FLAGS(old_object->properties) & IS_ARRAY_IMMUTABLE))) { @@ -258,6 +260,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_clone_members(zend_object *new_object, /* Unconditionally add the IS_PROP_REINITABLE flag to avoid a potential cache miss of property_info */ Z_PROP_FLAG_P(&new_prop) |= IS_PROP_REINITABLE; } + Z_PROP_FLAG_P(&new_prop) &= ~IS_PROP_REINITED; if (EXPECTED(key)) { _zend_hash_append(new_object->properties, key, &new_prop); } else { @@ -270,7 +273,7 @@ ZEND_API void ZEND_FASTCALL zend_objects_clone_members(zend_object *new_object, GC_ADDREF(new_object); zend_call_known_instance_method_with_0_params(new_object->ce->clone, new_object, NULL); - if (ZEND_CLASS_HAS_READONLY_PROPS(new_object->ce)) { + if (has_readonly_props) { for (uint32_t i = 0; i < new_object->ce->default_properties_count; i++) { zval* prop = OBJ_PROP_NUM(new_object, i); /* Unconditionally remove the IS_PROP_REINITABLE flag to avoid a potential cache miss of property_info */ diff --git a/Zend/zend_types.h b/Zend/zend_types.h index c4a07f58874ab..3cdb18137cb57 100644 --- a/Zend/zend_types.h +++ b/Zend/zend_types.h @@ -1559,7 +1559,10 @@ static zend_always_inline uint32_t zval_delref_p(zval* pz) { * the Z_EXTRA space when copying property default values etc. We define separate * macros for this purpose, so this workaround is easier to remove in the future. */ #define IS_PROP_UNINIT (1<<0) -#define IS_PROP_REINITABLE (1<<1) /* It has impact only on readonly properties */ +/* Unlocks readonly properties during cloning for exactly one assignment. It has no impact on regular properties. */ +#define IS_PROP_REINITABLE (1<<1) +/* Re-locks readonly properties during "clone with" operations. It has no impact on regular properties. */ +#define IS_PROP_REINITED (1<<2) #define Z_PROP_FLAG_P(z) Z_EXTRA_P(z) #define ZVAL_COPY_VALUE_PROP(z, v) \ do { *(z) = *(v); } while (0) diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h index bedd328332dd1..16c109cf43713 100644 --- a/Zend/zend_vm_def.h +++ b/Zend/zend_vm_def.h @@ -2418,7 +2418,16 @@ ZEND_VM_C_LABEL(assign_object): zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + ZEND_VM_C_GOTO(free_and_exit_assign_obj); + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } ZEND_VM_C_GOTO(free_and_exit_assign_obj); } else { ZEND_VM_C_LABEL(fast_assign_obj): @@ -2471,7 +2480,7 @@ ZEND_VM_C_LABEL(fast_assign_obj): } else if (OP_DATA_TYPE == 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); @@ -9675,6 +9684,131 @@ ZEND_VM_HANDLER(207, ZEND_FRAMELESS_ICALL_3, ANY, ANY) ZEND_VM_NEXT_OPCODE_EX(1, 2); } +ZEND_VM_HANDLER(209, ZEND_CLONE_INIT_PROP, VAR, CONST|TMPVAR|CV, CACHE_SLOT, SPEC(OP_DATA=CONST|TMP|VAR|CV)) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = GET_OP1_OBJ_ZVAL_PTR_PTR_UNDEF(BP_VAR_W); + value = GET_OP_DATA_ZVAL_PTR(BP_VAR_R); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + ZEND_VM_C_GOTO(free_and_exit_init_prop); + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + ZEND_VM_C_GOTO(free_and_exit_init_prop); + } else { +ZEND_VM_C_LABEL(fast_init_prop): + zend_assign_to_variable_ex(property_val, value, OP_DATA_TYPE, EX_USES_STRICT_TYPES(), &garbage); + ZEND_VM_C_GOTO(free_and_exit_init_prop); + } + } + } else { + zname = GET_OP2_ZVAL_PTR(BP_VAR_R); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + ZEND_VM_C_GOTO(free_and_exit_init_prop); + } + name = Z_STR_P(zname); + + 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) { + ZEND_VM_C_GOTO(fast_init_prop); + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + if (OP_DATA_TYPE == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (OP_DATA_TYPE != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (OP_DATA_TYPE == 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 (OP_DATA_TYPE == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + ZEND_VM_C_GOTO(free_and_exit_init_prop); + } + } + } + + zname = GET_OP2_ZVAL_PTR(BP_VAR_R); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + ZEND_VM_C_GOTO(free_and_exit_init_prop); + } + name = Z_STR_P(zname); + + if (OP_DATA_TYPE == IS_CV || OP_DATA_TYPE == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +ZEND_VM_C_LABEL(free_and_exit_init_prop): + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + FREE_OP_DATA(); + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + FREE_OP2(); + FREE_OP1(); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + ZEND_VM_HOT_TYPE_SPEC_HANDLER(ZEND_JMP, (OP_JMP_ADDR(op, op->op1) > op), ZEND_JMP_FORWARD, JMP_ADDR, ANY) { USE_OPLINE diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h index 61631bc492f4d..9143d50d61d14 100644 --- a/Zend/zend_vm_execute.h +++ b/Zend/zend_vm_execute.h @@ -23523,7 +23523,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -23576,7 +23585,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } else if (IS_CONST == 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); @@ -23657,7 +23666,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -23710,7 +23728,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } else if (IS_TMP_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); @@ -23791,7 +23809,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -23844,7 +23871,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } 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); @@ -23925,7 +23952,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -23978,7 +24014,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_OP_D } 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); @@ -25764,6 +25800,506 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IN_ARRAY_SPEC_VAR_CONST_HANDLE ZEND_VM_SMART_BRANCH(0, 1); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = RT_CONSTANT((opline+1), (opline+1)->op1); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = RT_CONSTANT(opline, opline->op2); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_CONST != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_CONST == 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_CONST == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + goto free_and_exit_init_prop; + } + } + } + + zname = RT_CONSTANT(opline, opline->op2); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = RT_CONSTANT(opline, opline->op2); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_TMP_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_TMP_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_TMP_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + goto free_and_exit_init_prop; + } + } + } + + zname = RT_CONSTANT(opline, opline->op2); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *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); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = RT_CONSTANT(opline, opline->op2); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + 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); + goto free_and_exit_init_prop; + } + } + } + + zname = RT_CONSTANT(opline, opline->op2); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + 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); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = RT_CONSTANT(opline, opline->op2); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + 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); + goto free_and_exit_init_prop; + } + } + } + + zname = RT_CONSTANT(opline, opline->op2); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FETCH_CLASS_CONSTANT_SPEC_VAR_TMPVARCV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { zend_class_entry *ce, *scope; @@ -26449,7 +26985,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -26502,7 +27047,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } else if (IS_CONST == 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); @@ -26583,7 +27128,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -26636,7 +27190,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } else if (IS_TMP_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); @@ -26717,7 +27271,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -26770,7 +27333,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } 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); @@ -26851,7 +27414,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -26904,7 +27476,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_TMPVAR_OP_ } 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); @@ -28145,6 +28717,506 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_TMPVAR_HANDLER( ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = RT_CONSTANT((opline+1), (opline+1)->op1); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_CONST != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_CONST == 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_CONST == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + goto free_and_exit_init_prop; + } + } + } + + zname = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + + 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)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_TMP_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_TMP_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_TMP_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + goto free_and_exit_init_prop; + } + } + } + + zname = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + 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)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *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); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + 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); + goto free_and_exit_init_prop; + } + } + } + + zname = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + 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)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + 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); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + 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); + goto free_and_exit_init_prop; + } + } + } + + zname = _get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + + 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)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -30741,7 +31813,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -30794,7 +31875,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } else if (IS_CONST == 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); @@ -30875,7 +31956,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -30928,7 +32018,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } else if (IS_TMP_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); @@ -31009,7 +32099,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -31062,7 +32161,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } 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); @@ -31143,7 +32242,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -31196,7 +32304,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_VAR_CV_OP_DATA } 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); @@ -32530,6 +33638,506 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND ZEND_VM_RETURN(); } +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = RT_CONSTANT((opline+1), (opline+1)->op1); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_CONST, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + if (IS_CONST == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_CONST != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_CONST == 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_CONST == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + goto free_and_exit_init_prop; + } + } + } + + zname = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_CONST == IS_CV || IS_CONST == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + SAVE_OPLINE(); + object = _get_zval_ptr_ptr_var(opline->op1.var EXECUTE_DATA_CC); + value = _get_zval_ptr_tmp((opline+1)->op1.var EXECUTE_DATA_CC); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_TMP_VAR, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + if (IS_TMP_VAR == IS_CONST) { + if (UNEXPECTED(Z_OPT_REFCOUNTED_P(value))) { + Z_ADDREF_P(value); + } + } else if (IS_TMP_VAR != IS_TMP_VAR) { + if (Z_ISREF_P(value)) { + if (IS_TMP_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_TMP_VAR == IS_CV) { + Z_TRY_ADDREF_P(value); + } + } + zend_hash_add_new(zobj->properties, name, value); + goto free_and_exit_init_prop; + } + } + } + + zname = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *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); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_VAR, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + 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); + goto free_and_exit_init_prop; + } + } + } + + zname = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_VAR == IS_CV || IS_VAR == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + zval_ptr_dtor_nogc(EX_VAR((opline+1)->op1.var)); + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + +static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS) +{ + USE_OPLINE + zval *object, *zname, *value, tmp; + zend_object *zobj; + zend_string *name; + zend_refcounted *garbage = NULL; + + 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); + + assert(Z_TYPE_P(object) == IS_OBJECT); + + zobj = Z_OBJ_P(object); + void **cache_slot = CACHE_ADDR(opline->extended_value); + if (EXPECTED(zobj->ce == CACHED_PTR(opline->extended_value))) { + uintptr_t prop_offset = (uintptr_t)CACHED_PTR_EX(cache_slot + 1); + zval *property_val; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (UNEXPECTED(prop_info != NULL)) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && (Z_PROP_FLAG_P(property_val) & IS_PROP_REINITED))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_init_prop; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) |= IS_PROP_REINITED; + } + goto free_and_exit_init_prop; + } else { +fast_init_prop: + zend_assign_to_variable_ex(property_val, value, IS_CV, EX_USES_STRICT_TYPES(), &garbage); + goto free_and_exit_init_prop; + } + } + } else { + zname = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + 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_init_prop; + } + } + + if (!zobj->ce->__set && (zobj->ce->ce_flags & ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES)) { + if (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + 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); + goto free_and_exit_init_prop; + } + } + } + + zname = _get_zval_ptr_cv_BP_VAR_R(opline->op2.var EXECUTE_DATA_CC); + if (Z_TYPE_P(zname) != IS_STRING) { + zend_throw_error(zend_ce_type_error, "Property name must be of type string, %s given", zend_zval_type_name(zname)); + goto free_and_exit_init_prop; + } + name = Z_STR_P(zname); + + if (IS_CV == IS_CV || IS_CV == IS_VAR) { + ZVAL_DEREF(value); + } + + value = zobj->handlers->write_property(zobj, name, value, cache_slot); + +free_and_exit_init_prop: + if (RETURN_VALUE_USED(opline) && value) { + ZVAL_COPY_DEREF(EX_VAR(opline->result.var), object); + } + + if (garbage) { + GC_DTOR_NO_REF(garbage); + } + + zval_ptr_dtor_nogc(EX_VAR(opline->op1.var)); + /* ZEND_CLONE_INIT_PROP has two opcodes! */ + ZEND_VM_NEXT_OPCODE_EX(1, 2); +} + static ZEND_VM_HOT ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS) { USE_OPLINE @@ -33374,7 +34982,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -33427,7 +35044,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } else if (IS_CONST == 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); @@ -33508,7 +35125,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -33561,7 +35187,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } else if (IS_TMP_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); @@ -33642,7 +35268,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -33695,7 +35330,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } 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); @@ -33776,7 +35411,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -33829,7 +35473,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_O } 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); @@ -35428,7 +37072,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -35481,7 +37134,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } else if (IS_CONST == 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); @@ -35562,7 +37215,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -35615,7 +37277,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } else if (IS_TMP_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); @@ -35696,141 +37358,159 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { - value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage 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 { - name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); - 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); + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } + 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 { + name = Z_STR_P(_get_zval_ptr_var(opline->op2.var EXECUTE_DATA_CC)); + 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 (EXPECTED(zobj->properties == NULL)) { + rebuild_object_properties(zobj); + } + 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; + } + } + } + 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_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_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_cv_BP_VAR_R((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; + + if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { + property_val = OBJ_PROP(zobj, prop_offset); + if (Z_TYPE_P(property_val) != IS_UNDEF) { + zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); + + if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; } - 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 (EXPECTED(zobj->properties == NULL)) { - rebuild_object_properties(zobj); - } - 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; - } - } - } - 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_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_OP_DATA_CV_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_cv_BP_VAR_R((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; - - if (EXPECTED(IS_VALID_PROPERTY_OFFSET(prop_offset))) { - property_val = OBJ_PROP(zobj, prop_offset); - if (Z_TYPE_P(property_val) != IS_UNDEF) { - zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); - - if (prop_info != NULL) { value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -35883,7 +37563,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMPVAR_ } 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); @@ -37934,7 +39614,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -37987,7 +39676,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } else if (IS_CONST == 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); @@ -38068,7 +39757,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -38121,7 +39819,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } else if (IS_TMP_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); @@ -38202,7 +39900,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -38255,7 +39962,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } 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); @@ -38336,7 +40043,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -38389,7 +40105,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_OP_D } 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); @@ -42209,7 +43925,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -42262,7 +43987,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } else if (IS_CONST == 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); @@ -42343,7 +44068,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -42396,7 +44130,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } else if (IS_TMP_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); @@ -42477,7 +44211,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -42530,7 +44273,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } 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); @@ -42611,7 +44354,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -42664,7 +44416,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CONST_OP_DA } 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); @@ -46048,7 +47800,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -46101,7 +47862,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } else if (IS_CONST == 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); @@ -46182,7 +47943,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -46235,7 +48005,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } else if (IS_TMP_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); @@ -46316,7 +48086,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -46369,7 +48148,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } 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); @@ -46450,7 +48229,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -46503,7 +48291,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_TMPVAR_OP_D } 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); @@ -51439,7 +53227,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -51492,7 +53289,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } else if (IS_CONST == 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); @@ -51573,7 +53370,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -51626,7 +53432,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } else if (IS_TMP_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); @@ -51707,7 +53513,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -51760,7 +53575,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } 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); @@ -51841,7 +53656,16 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ zend_property_info *prop_info = (zend_property_info*) CACHED_PTR_EX(cache_slot + 2); if (prop_info != NULL) { + if (UNEXPECTED((prop_info->flags & ZEND_ACC_READONLY) && !(Z_PROP_FLAG_P(property_val) & IS_PROP_REINITABLE))) { + zend_readonly_property_modification_error(prop_info); + value = &EG(uninitialized_zval); + goto free_and_exit_assign_obj; + } + value = zend_assign_to_typed_prop(prop_info, property_val, value, &garbage EXECUTE_DATA_CC); + if (value != &EG(uninitialized_zval)) { + Z_PROP_FLAG_P(property_val) &= ~IS_PROP_REINITABLE; + } goto free_and_exit_assign_obj; } else { fast_assign_obj: @@ -51894,7 +53718,7 @@ static ZEND_OPCODE_HANDLER_RET ZEND_FASTCALL ZEND_ASSIGN_OBJ_SPEC_CV_CV_OP_DATA_ } 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); @@ -56192,6 +58016,31 @@ ZEND_API void execute_ex(zend_execute_data *ex) (void*)&&ZEND_FRAMELESS_ICALL_2_SPEC_LABEL, (void*)&&ZEND_FRAMELESS_ICALL_3_SPEC_LABEL, (void*)&&ZEND_JMP_FRAMELESS_SPEC_CONST_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CONST_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_TMP_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CV_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CONST_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_TMP_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_VAR_LABEL, + (void*)&&ZEND_NULL_LABEL, + (void*)&&ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CV_LABEL, (void*)&&ZEND_INIT_FCALL_OFFSET_SPEC_CONST_LABEL, (void*)&&ZEND_RECV_NOTYPE_SPEC_LABEL, (void*)&&ZEND_NULL_LABEL, @@ -60361,6 +62210,26 @@ ZEND_API void execute_ex(zend_execute_data *ex) 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_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CONST): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CONST) + ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_TMP): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_TMP) + ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_VAR): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_VAR) + ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CV): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CV) + ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CV) + 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); @@ -60516,6 +62385,26 @@ ZEND_API void execute_ex(zend_execute_data *ex) 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_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST) + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP) + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR) + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV) + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV) + 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); @@ -60871,6 +62760,26 @@ ZEND_API void execute_ex(zend_execute_data *ex) ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); VM_TRACE_OP_END(ZEND_YIELD_SPEC_VAR_CV) HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CONST): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CONST) + ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CONST) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_TMP): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_TMP) + ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_TMP) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_VAR): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_VAR) + ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_VAR) + HYBRID_BREAK(); + HYBRID_CASE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CV): + VM_TRACE(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CV) + ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); + VM_TRACE_OP_END(ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CV) + HYBRID_BREAK(); HYBRID_CASE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED): VM_TRACE(ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU); @@ -65355,6 +67264,31 @@ void zend_vm_init(void) ZEND_FRAMELESS_ICALL_2_SPEC_HANDLER, ZEND_FRAMELESS_ICALL_3_SPEC_HANDLER, ZEND_JMP_FRAMELESS_SPEC_CONST_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CONST_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_TMP_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CV_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CONST_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_TMP_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_VAR_HANDLER, + ZEND_NULL_HANDLER, + ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CV_HANDLER, ZEND_INIT_FCALL_OFFSET_SPEC_CONST_HANDLER, ZEND_RECV_NOTYPE_SPEC_HANDLER, ZEND_NULL_HANDLER, @@ -66312,7 +68246,7 @@ void zend_vm_init(void) 1255, 1256 | SPEC_RULE_OP1, 1261 | SPEC_RULE_OP1, - 3482, + 3507, 1266 | SPEC_RULE_OP1, 1271 | SPEC_RULE_OP1, 1276 | SPEC_RULE_OP2, @@ -66476,53 +68410,53 @@ void zend_vm_init(void) 2570, 2571, 2572, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, - 3482, + 2573 | SPEC_RULE_OP2 | SPEC_RULE_OP_DATA, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, + 3507, }; #if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID) zend_opcode_handler_funcs = labels; @@ -66695,7 +68629,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 = 2581 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2606 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -66703,7 +68637,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 = 2606 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2631 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -66711,7 +68645,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 = 2631 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2656 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; if (op->op1_type < op->op2_type) { zend_swap_operands(op); } @@ -66722,17 +68656,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 = 2656 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2681 | 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 = 2681 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2706 | 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 = 2706 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 2731 | SPEC_RULE_OP1 | SPEC_RULE_OP2; } break; case ZEND_MUL: @@ -66743,17 +68677,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 = 2731 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2756 | 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 = 2756 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2781 | 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 = 2781 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 2806 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_IDENTICAL: @@ -66764,14 +68698,14 @@ 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 = 2806 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2831 | 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 = 2881 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2906 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | 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 = 3106 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3131 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_IDENTICAL: @@ -66782,14 +68716,14 @@ 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 = 2956 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2981 | 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 = 3031 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3056 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | 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 = 3111 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; + spec = 3136 | SPEC_RULE_OP2 | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_EQUAL: @@ -66800,12 +68734,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 = 2806 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2831 | 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 = 2881 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2906 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_NOT_EQUAL: @@ -66816,12 +68750,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 = 2956 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 2981 | 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 = 3031 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; + spec = 3056 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH | SPEC_RULE_COMMUTATIVE; } break; case ZEND_IS_SMALLER: @@ -66829,12 +68763,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 = 3116 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3141 | 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 = 3191 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3216 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_IS_SMALLER_OR_EQUAL: @@ -66842,79 +68776,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 = 3266 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3291 | 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 = 3341 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; + spec = 3366 | SPEC_RULE_OP1 | SPEC_RULE_OP2 | SPEC_RULE_SMART_BRANCH; } break; case ZEND_QM_ASSIGN: if (op1_info == MAY_BE_LONG) { - spec = 3428 | SPEC_RULE_OP1; + spec = 3453 | SPEC_RULE_OP1; } else if (op1_info == MAY_BE_DOUBLE) { - spec = 3433 | SPEC_RULE_OP1; + spec = 3458 | 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 = 3438 | SPEC_RULE_OP1; + spec = 3463 | SPEC_RULE_OP1; } break; case ZEND_PRE_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3416 | SPEC_RULE_RETVAL; + spec = 3441 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3418 | SPEC_RULE_RETVAL; + spec = 3443 | SPEC_RULE_RETVAL; } break; case ZEND_PRE_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3420 | SPEC_RULE_RETVAL; + spec = 3445 | SPEC_RULE_RETVAL; } else if (op1_info == MAY_BE_LONG) { - spec = 3422 | SPEC_RULE_RETVAL; + spec = 3447 | SPEC_RULE_RETVAL; } break; case ZEND_POST_INC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3424; + spec = 3449; } else if (op1_info == MAY_BE_LONG) { - spec = 3425; + spec = 3450; } break; case ZEND_POST_DEC: if (res_info == MAY_BE_LONG && op1_info == MAY_BE_LONG) { - spec = 3426; + spec = 3451; } else if (op1_info == MAY_BE_LONG) { - spec = 3427; + spec = 3452; } break; case ZEND_JMP: if (OP_JMP_ADDR(op, op->op1) > op) { - spec = 2580; + spec = 2605; } break; case ZEND_INIT_FCALL: if (Z_EXTRA_P(RT_CONSTANT(op, op->op2)) != 0) { - spec = 2573; + spec = 2598; } break; case ZEND_RECV: if (op->op2.num == MAY_BE_ANY) { - spec = 2574; + spec = 2599; } 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 = 3478; + spec = 3503; } 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 = 3473 | SPEC_RULE_OP1; + spec = 3498 | 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 = 3480 | SPEC_RULE_RETVAL; + spec = 3505 | SPEC_RULE_RETVAL; } break; case ZEND_FETCH_DIM_R: @@ -66922,22 +68856,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 = 3443 | SPEC_RULE_OP1 | SPEC_RULE_OP2; + spec = 3468 | 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 = 3479; + spec = 3504; } break; case ZEND_SEND_VAR: if (op->op2_type == IS_UNUSED && (op1_info & (MAY_BE_UNDEF|MAY_BE_REF)) == 0) { - spec = 3468 | SPEC_RULE_OP1; + spec = 3493 | SPEC_RULE_OP1; } break; case ZEND_COUNT: if ((op1_info & (MAY_BE_ANY|MAY_BE_UNDEF|MAY_BE_REF)) == MAY_BE_ARRAY) { - spec = 2575 | SPEC_RULE_OP1; + spec = 2600 | SPEC_RULE_OP1; } break; case ZEND_BW_OR: diff --git a/Zend/zend_vm_handlers.h b/Zend/zend_vm_handlers.h index dd5a6ca03d0cb..1682b636e0d64 100644 --- a/Zend/zend_vm_handlers.h +++ b/Zend/zend_vm_handlers.h @@ -1368,502 +1368,518 @@ _(2570, ZEND_FRAMELESS_ICALL_2_SPEC) \ _(2571, ZEND_FRAMELESS_ICALL_3_SPEC) \ _(2572, ZEND_JMP_FRAMELESS_SPEC_CONST) \ - _(2573, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ - _(2574, ZEND_RECV_NOTYPE_SPEC) \ - _(2576, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2577, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ - _(2579, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ - _(2580, ZEND_JMP_FORWARD_SPEC) \ - _(2586, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2587, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2588, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2590, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2591, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2592, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2593, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2595, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2601, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2602, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2603, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2605, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2611, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2612, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2613, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2615, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2616, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2617, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2618, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2620, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2626, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ - _(2627, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2628, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2630, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2636, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2637, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2638, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2640, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2641, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2642, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2643, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2645, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2651, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2652, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2653, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2655, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2657, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2658, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2660, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ - _(2661, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2662, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2663, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2665, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2666, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2667, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2668, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2670, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2676, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2677, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2678, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2680, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2682, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2683, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2685, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ - _(2686, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2687, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2688, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2690, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2691, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2692, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2693, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2695, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2701, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ - _(2702, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2703, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2705, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2707, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2708, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2710, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(2711, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2712, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2713, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2715, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2716, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2717, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2718, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2720, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2726, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2727, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2728, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2730, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2736, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2737, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2738, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2740, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2741, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2742, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2743, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2745, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2751, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ - _(2752, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2753, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2755, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ - _(2761, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2762, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2763, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2765, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2766, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2767, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2768, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2770, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2776, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ - _(2777, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2778, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2780, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2786, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2787, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2788, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2790, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2791, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2792, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2793, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2795, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2801, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2802, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2803, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2805, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2821, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2822, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2823, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2824, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2825, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2826, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2827, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2828, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2829, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2833, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2834, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2835, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2836, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2837, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2838, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2839, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2840, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2841, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2842, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2843, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2844, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2870, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2871, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2872, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2878, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2879, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2880, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2896, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2897, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2898, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2899, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2900, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2901, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2902, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2903, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2904, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2908, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2909, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2910, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2911, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2912, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2913, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2914, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2915, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2916, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2917, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2918, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2919, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2945, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2946, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2947, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2953, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(2954, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2955, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2971, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2972, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2973, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2974, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2975, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2976, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2977, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2978, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2979, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2983, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2984, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2985, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2986, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(2987, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(2988, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(2989, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2990, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2991, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2992, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2993, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(2994, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3020, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3021, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3022, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3028, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3029, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3030, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3046, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3047, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3048, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3049, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3050, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3051, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3052, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3053, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3054, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3058, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3059, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3060, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3061, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3062, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3063, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3064, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3065, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3066, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3067, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3068, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3069, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3095, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3096, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3097, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3103, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3104, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3105, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3106, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3110, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3111, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ - _(3115, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ - _(3119, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3120, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3121, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3122, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3123, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3124, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3128, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ - _(3129, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3130, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3131, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3132, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3133, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3134, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3135, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3136, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3137, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3138, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3139, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3143, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3144, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3145, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3146, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3147, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3148, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3149, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3150, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3151, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3152, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3153, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3154, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ - _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3180, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3181, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3182, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3188, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3189, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3190, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3194, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3195, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3196, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3197, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3198, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3199, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3203, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3204, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3205, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3206, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3207, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3208, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3209, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3210, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3211, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3212, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3213, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3214, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3218, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3225, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3226, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3227, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3255, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3256, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3257, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3263, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3264, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3265, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3269, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3270, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3271, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3272, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3273, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3274, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3278, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ - _(3279, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3280, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3281, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3282, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3283, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3284, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3285, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3286, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3287, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3288, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3289, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3293, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3300, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3301, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3302, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ - _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3330, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3331, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3332, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3338, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ - _(3339, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3340, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3344, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3345, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3346, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3347, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3348, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3349, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3353, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ - _(3354, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ - _(3355, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ - _(3356, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3357, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3358, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3359, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3360, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3361, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3362, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3363, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3364, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3368, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3375, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3376, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3377, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ - _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ - _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ - _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3405, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3406, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3407, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3413, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ - _(3414, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ - _(3415, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ - _(3416, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3417, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3418, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3419, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ - _(3420, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ - _(3421, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ - _(3422, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ - _(3423, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ - _(3424, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3425, ZEND_POST_INC_LONG_SPEC_CV) \ - _(3426, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ - _(3427, ZEND_POST_DEC_LONG_SPEC_CV) \ - _(3428, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ - _(3429, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3430, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3432, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ - _(3433, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ - _(3434, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3435, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3437, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ - _(3438, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ - _(3439, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3440, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3442, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ - _(3444, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3445, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3447, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ - _(3448, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3449, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3450, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3452, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3453, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ - _(3454, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3455, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3457, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ - _(3463, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ - _(3464, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3465, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3467, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ - _(3470, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ - _(3472, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ - _(3475, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ - _(3477, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ - _(3478, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ - _(3479, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ - _(3480, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ - _(3481, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ - _(3481+1, ZEND_NULL) + _(2573, ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CONST) \ + _(2574, ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_TMP) \ + _(2575, ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_VAR) \ + _(2577, ZEND_CLONE_INIT_PROP_SPEC_VAR_CONST_OP_DATA_CV) \ + _(2578, ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ + _(2579, ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ + _(2580, ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(2582, ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(2583, ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CONST) \ + _(2584, ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_TMP) \ + _(2585, ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_VAR) \ + _(2587, ZEND_CLONE_INIT_PROP_SPEC_VAR_TMPVAR_OP_DATA_CV) \ + _(2593, ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CONST) \ + _(2594, ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_TMP) \ + _(2595, ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_VAR) \ + _(2597, ZEND_CLONE_INIT_PROP_SPEC_VAR_CV_OP_DATA_CV) \ + _(2598, ZEND_INIT_FCALL_OFFSET_SPEC_CONST) \ + _(2599, ZEND_RECV_NOTYPE_SPEC) \ + _(2601, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ + _(2602, ZEND_COUNT_ARRAY_SPEC_TMPVAR_UNUSED) \ + _(2604, ZEND_COUNT_ARRAY_SPEC_CV_UNUSED) \ + _(2605, ZEND_JMP_FORWARD_SPEC) \ + _(2611, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2612, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2613, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2615, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2616, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2617, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2618, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2620, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2626, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2627, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2628, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2630, ZEND_ADD_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2636, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2637, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2638, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2640, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2641, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2642, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2643, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2645, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2651, ZEND_ADD_LONG_SPEC_TMPVARCV_CONST) \ + _(2652, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2653, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2655, ZEND_ADD_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2661, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2662, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2663, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2665, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2666, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2667, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2668, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2670, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2676, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2677, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2678, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2680, ZEND_ADD_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2682, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2683, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2685, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_CONST_TMPVARCV) \ + _(2686, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2687, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2688, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2690, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2691, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2692, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2693, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2695, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2701, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2702, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2703, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2705, ZEND_SUB_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2707, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2708, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2710, ZEND_SUB_LONG_SPEC_CONST_TMPVARCV) \ + _(2711, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2712, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2713, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2715, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2716, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2717, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2718, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2720, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2726, ZEND_SUB_LONG_SPEC_TMPVARCV_CONST) \ + _(2727, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2728, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2730, ZEND_SUB_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2732, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2733, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2735, ZEND_SUB_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(2736, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2737, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2738, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2740, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2741, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2742, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2743, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2745, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2751, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2752, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2753, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2755, ZEND_SUB_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2761, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2762, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2763, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2765, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2766, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2767, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2768, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2770, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2776, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_CONST) \ + _(2777, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2778, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2780, ZEND_MUL_LONG_NO_OVERFLOW_SPEC_TMPVARCV_TMPVARCV) \ + _(2786, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2787, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2788, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2790, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2791, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2792, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2793, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2795, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2801, ZEND_MUL_LONG_SPEC_TMPVARCV_CONST) \ + _(2802, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2803, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2805, ZEND_MUL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2811, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2812, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2813, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2815, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2816, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2817, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2818, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2820, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2826, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2827, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2828, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2830, ZEND_MUL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2846, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2847, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2848, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2849, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2850, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2851, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2852, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2853, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2854, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2858, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2859, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2860, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2861, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2862, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2863, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2864, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2865, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2866, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2867, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2868, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2869, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2873, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2874, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2875, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2891, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2892, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2893, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2894, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2895, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2896, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2897, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2898, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2899, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2903, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(2904, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2905, ZEND_IS_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2921, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2922, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2923, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2924, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2925, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2926, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2927, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2928, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2929, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2933, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2934, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2935, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2936, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2937, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2938, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2939, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2940, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2941, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2942, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2943, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2944, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2948, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2949, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2950, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2966, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(2967, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2968, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2969, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2970, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2971, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2972, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2973, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2974, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2978, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(2979, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(2980, ZEND_IS_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(2996, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(2997, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(2998, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(2999, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3000, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3001, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3002, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3003, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3004, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3008, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3009, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3010, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3011, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3012, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3013, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3014, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3015, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3016, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3017, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3018, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3019, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3023, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3024, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3025, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3041, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3042, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3043, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3044, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3045, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3046, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3047, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3048, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3049, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3053, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3054, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3055, ZEND_IS_NOT_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3071, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3072, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3073, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3074, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3075, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3076, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3077, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3078, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3079, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3083, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3084, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3085, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3086, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3087, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3088, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3089, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3090, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3091, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3092, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3093, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3094, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3098, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3099, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3100, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3116, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3117, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3118, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3119, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3120, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3121, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3122, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3123, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3124, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3128, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3129, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3130, ZEND_IS_NOT_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3131, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3135, ZEND_IS_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3136, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CONST) \ + _(3140, ZEND_IS_NOT_IDENTICAL_NOTHROW_SPEC_CV_CV) \ + _(3144, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3145, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3146, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3147, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3148, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3149, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3153, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV) \ + _(3154, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3155, ZEND_IS_SMALLER_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3156, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3157, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3158, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3159, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3160, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3161, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3162, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3163, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3164, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3168, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3169, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3170, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3171, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3172, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3173, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3174, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3175, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3176, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3177, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3178, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3179, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3183, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3184, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3185, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3201, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST) \ + _(3202, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3203, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3204, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3205, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3206, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3207, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3208, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3209, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3213, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3214, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3215, ZEND_IS_SMALLER_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3219, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3220, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3221, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3222, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3223, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3224, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3228, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3229, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3230, ZEND_IS_SMALLER_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3231, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3232, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3233, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3234, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3235, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3236, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3237, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3238, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3239, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3243, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3244, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3245, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3246, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3247, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3248, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3249, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3250, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3251, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3252, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3253, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3254, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3258, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3259, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3260, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3276, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3277, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3278, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3279, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3280, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3281, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3282, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3283, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3284, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3288, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3289, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3290, ZEND_IS_SMALLER_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3294, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3295, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3296, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3297, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3298, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3299, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3303, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV) \ + _(3304, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3305, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3306, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3307, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3308, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3309, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3310, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3311, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3312, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3313, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3314, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3318, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3319, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3320, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3321, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3322, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3323, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3324, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3325, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3326, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3327, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3328, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3329, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3333, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3334, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3335, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3351, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST) \ + _(3352, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3353, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3354, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3355, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3356, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3357, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3358, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3359, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3363, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV) \ + _(3364, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3365, ZEND_IS_SMALLER_OR_EQUAL_LONG_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3369, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3370, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3371, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3372, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3373, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3374, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3378, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV) \ + _(3379, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPZ) \ + _(3380, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_CONST_TMPVARCV_JMPNZ) \ + _(3381, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3382, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3383, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3384, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3385, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3386, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3387, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3388, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3389, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3393, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3394, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3395, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3396, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3397, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3398, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3399, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3400, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3401, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3402, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3403, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3404, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3408, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3409, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3410, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3426, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST) \ + _(3427, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPZ) \ + _(3428, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_CONST_JMPNZ) \ + _(3429, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3430, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3431, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3432, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3433, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3434, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3438, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV) \ + _(3439, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPZ) \ + _(3440, ZEND_IS_SMALLER_OR_EQUAL_DOUBLE_SPEC_TMPVARCV_TMPVARCV_JMPNZ) \ + _(3441, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3442, ZEND_PRE_INC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3443, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3444, ZEND_PRE_INC_LONG_SPEC_CV_RETVAL_USED) \ + _(3445, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_UNUSED) \ + _(3446, ZEND_PRE_DEC_LONG_NO_OVERFLOW_SPEC_CV_RETVAL_USED) \ + _(3447, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_UNUSED) \ + _(3448, ZEND_PRE_DEC_LONG_SPEC_CV_RETVAL_USED) \ + _(3449, ZEND_POST_INC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3450, ZEND_POST_INC_LONG_SPEC_CV) \ + _(3451, ZEND_POST_DEC_LONG_NO_OVERFLOW_SPEC_CV) \ + _(3452, ZEND_POST_DEC_LONG_SPEC_CV) \ + _(3453, ZEND_QM_ASSIGN_LONG_SPEC_CONST) \ + _(3454, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3455, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3457, ZEND_QM_ASSIGN_LONG_SPEC_TMPVARCV) \ + _(3458, ZEND_QM_ASSIGN_DOUBLE_SPEC_CONST) \ + _(3459, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3460, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3462, ZEND_QM_ASSIGN_DOUBLE_SPEC_TMPVARCV) \ + _(3463, ZEND_QM_ASSIGN_NOREF_SPEC_CONST) \ + _(3464, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3465, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3467, ZEND_QM_ASSIGN_NOREF_SPEC_TMPVARCV) \ + _(3469, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3470, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3472, ZEND_FETCH_DIM_R_INDEX_SPEC_CONST_TMPVARCV) \ + _(3473, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3474, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3475, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3477, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3478, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_CONST) \ + _(3479, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3480, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3482, ZEND_FETCH_DIM_R_INDEX_SPEC_TMPVAR_TMPVARCV) \ + _(3488, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_CONST) \ + _(3489, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3490, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3492, ZEND_FETCH_DIM_R_INDEX_SPEC_CV_TMPVARCV) \ + _(3495, ZEND_SEND_VAR_SIMPLE_SPEC_VAR) \ + _(3497, ZEND_SEND_VAR_SIMPLE_SPEC_CV) \ + _(3500, ZEND_SEND_VAR_EX_SIMPLE_SPEC_VAR_UNUSED) \ + _(3502, ZEND_SEND_VAR_EX_SIMPLE_SPEC_CV_UNUSED) \ + _(3503, ZEND_SEND_VAL_SIMPLE_SPEC_CONST) \ + _(3504, ZEND_SEND_VAL_EX_SIMPLE_SPEC_CONST) \ + _(3505, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_UNUSED) \ + _(3506, ZEND_FE_FETCH_R_SIMPLE_SPEC_VAR_CV_RETVAL_USED) \ + _(3506+1, ZEND_NULL) diff --git a/Zend/zend_vm_opcodes.c b/Zend/zend_vm_opcodes.c index 218a55a8f4e8b..2a78d8830cf45 100644 --- a/Zend/zend_vm_opcodes.c +++ b/Zend/zend_vm_opcodes.c @@ -22,7 +22,7 @@ #include #include -static const char *zend_vm_opcodes_names[209] = { +static const char *zend_vm_opcodes_names[210] = { "ZEND_NOP", "ZEND_ADD", "ZEND_SUB", @@ -232,9 +232,10 @@ static const char *zend_vm_opcodes_names[209] = { "ZEND_FRAMELESS_ICALL_2", "ZEND_FRAMELESS_ICALL_3", "ZEND_JMP_FRAMELESS", + "ZEND_CLONE_INIT_PROP", }; -static uint32_t zend_vm_opcodes_flags[209] = { +static uint32_t zend_vm_opcodes_flags[210] = { 0x00000000, 0x00000b0b, 0x00000b0b, @@ -444,6 +445,7 @@ static uint32_t zend_vm_opcodes_flags[209] = { 0x00000000, 0x00000000, 0x01042003, + 0x00040701, }; ZEND_API const char* ZEND_FASTCALL zend_get_opcode_name(uint8_t opcode) { diff --git a/Zend/zend_vm_opcodes.h b/Zend/zend_vm_opcodes.h index a273a9b7e2de0..34beca545ba3d 100644 --- a/Zend/zend_vm_opcodes.h +++ b/Zend/zend_vm_opcodes.h @@ -291,7 +291,8 @@ END_EXTERN_C() #define ZEND_FRAMELESS_ICALL_2 206 #define ZEND_FRAMELESS_ICALL_3 207 #define ZEND_JMP_FRAMELESS 208 +#define ZEND_CLONE_INIT_PROP 209 -#define ZEND_VM_LAST_OPCODE 208 +#define ZEND_VM_LAST_OPCODE 209 #endif diff --git a/ext/opcache/tests/clone_with_exception_handling.phpt b/ext/opcache/tests/clone_with_exception_handling.phpt new file mode 100644 index 0000000000000..ed381bc226dcc --- /dev/null +++ b/ext/opcache/tests/clone_with_exception_handling.phpt @@ -0,0 +1,49 @@ +--TEST-- +Opcache does not eliminate try-catch block around clone with +--EXTENSIONS-- +opcache +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.opt_debug_level=0x20000 +--FILE-- + []]; +} catch (TypeError $e) { + echo $e->getMessage() . "\n"; +} + +?> +--EXPECTF-- +$_main: + ; %s + ; (after optimizer) + ; %s +0000 V2 = NEW 0 string("Foo") +0001 DO_FCALL +0002 ASSIGN CV0($obj1) V2 +0003 V2 = CLONE CV0($obj1) +0004 CLONE_INIT_PROP V2 string("bar") +0005 OP_DATA array(...) +0006 RETURN int(1) +0007 CV1($e) = CATCH string("TypeError") +0008 INIT_METHOD_CALL 0 CV1($e) string("getMessage") +0009 V3 = DO_FCALL +0010 T2 = CONCAT V3 string(" +") +0011 ECHO T2 +0012 RETURN int(1) +LIVE RANGES: + 2: 0001 - 0002 (new) +EXCEPTION TABLE: + 0003, 0007, -, - +Cannot assign array to property Foo::$bar of type int diff --git a/ext/opcache/tests/clone_with_property_initialization.phpt b/ext/opcache/tests/clone_with_property_initialization.phpt new file mode 100644 index 0000000000000..8bab972afb2b5 --- /dev/null +++ b/ext/opcache/tests/clone_with_property_initialization.phpt @@ -0,0 +1,60 @@ +--TEST-- +Clone with property initialization +--EXTENSIONS-- +opcache +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.opt_debug_level=0x20000 +--FILE-- + 2, "b" => new stdClass()]; +} + +function getPropertyName($prop) { + return $prop; +} + +?> +--EXPECTF-- +$_main: + ; %s + ; (after optimizer) + ; %s +0000 RETURN int(1) + +test: + ; %s + ; (after optimizer) + ; %s +0000 V1 = NEW 0 string("stdClass") +0001 DO_FCALL +0002 CV0($obj) = QM_ASSIGN V1 +0003 V1 = CLONE CV0($obj) +0004 INIT_FCALL 1 96 string("getpropertyname") +0005 SEND_VAL string("a") 1 +0006 V2 = DO_UCALL +0007 T3 = CLONE_INIT_PROP V1 V2 +0008 OP_DATA int(2) +0009 V2 = NEW 0 string("stdClass") +0010 DO_FCALL +0011 V1 = CLONE_INIT_PROP T3 string("b") +0012 OP_DATA V2 +0013 RETURN V1 +LIVE RANGES: +%s +%s +%s +%s +%s + +getPropertyName: + ; %s + ; (after optimizer) + ; %s +0000 CV0($prop) = RECV 1 +0001 RETURN CV0($prop) diff --git a/ext/opcache/tests/clone_with_property_initialization_unused_return.phpt b/ext/opcache/tests/clone_with_property_initialization_unused_return.phpt new file mode 100644 index 0000000000000..3f774658e0e5d --- /dev/null +++ b/ext/opcache/tests/clone_with_property_initialization_unused_return.phpt @@ -0,0 +1,37 @@ +--TEST-- +Clone with property initialization +--EXTENSIONS-- +opcache +--INI-- +opcache.enable=1 +opcache.enable_cli=1 +opcache.opt_debug_level=0x20000 +--FILE-- + 1, "y" => 2, "z" => 3]; + +?> +===DONE=== +--EXPECTF-- +$_main: + ; %s + ; (after optimizer) + ; %s +0000 V1 = NEW 0 string("stdClass") +0001 DO_FCALL +0002 V0 = CLONE V1 +0003 T1 = CLONE_INIT_PROP V0 string("x") +0004 OP_DATA int(1) +0005 T0 = CLONE_INIT_PROP T1 string("y") +0006 OP_DATA int(2) +0007 CLONE_INIT_PROP T0 string("z") +0008 OP_DATA int(3) +0009 ECHO string("===DONE=== +") +0010 RETURN int(1) +LIVE RANGES: +%s +%s +%s +===DONE=== diff --git a/ext/reflection/tests/ReflectionParameter_new_initializer.phpt b/ext/reflection/tests/ReflectionParameter_new_initializer.phpt index 265ab14f89116..2f416ace5a1a1 100644 --- a/ext/reflection/tests/ReflectionParameter_new_initializer.phpt +++ b/ext/reflection/tests/ReflectionParameter_new_initializer.phpt @@ -5,7 +5,7 @@ ReflectionParameter::__toString() with new initializer function test( $p1 = new stdClass, - $p2 = new SomeClass(new With, some: new Parameters) + $p2 = new SomeClass(new Foo, some: new Bar) ) {} echo new ReflectionParameter('test', 'p1'), "\n"; @@ -14,4 +14,4 @@ echo new ReflectionParameter('test', 'p2'), "\n"; ?> --EXPECT-- Parameter #0 [ $p1 = new \stdClass() ] -Parameter #1 [ $p2 = new \SomeClass(new \With(), some: new \Parameters()) ] +Parameter #1 [ $p2 = new \SomeClass(new \Foo(), some: new \Bar()) ] diff --git a/ext/tokenizer/tokenizer_data.c b/ext/tokenizer/tokenizer_data.c index 77b67de6b1c6e..ac87a3efc04bc 100644 --- a/ext/tokenizer/tokenizer_data.c +++ b/ext/tokenizer/tokenizer_data.c @@ -53,6 +53,7 @@ char *get_token_type_name(int token_type) case T_INSTANCEOF: return "T_INSTANCEOF"; case T_NEW: return "T_NEW"; case T_CLONE: return "T_CLONE"; + case T_WITH: return "T_WITH"; case T_EXIT: return "T_EXIT"; case T_IF: return "T_IF"; case T_ELSEIF: return "T_ELSEIF"; diff --git a/ext/tokenizer/tokenizer_data.stub.php b/ext/tokenizer/tokenizer_data.stub.php index 42c69c4f82eff..6e047cf3d4e57 100644 --- a/ext/tokenizer/tokenizer_data.stub.php +++ b/ext/tokenizer/tokenizer_data.stub.php @@ -132,6 +132,11 @@ * @cvalue T_CLONE */ const T_CLONE = UNKNOWN; +/** + * @var int + * @cvalue T_WITH + */ +const T_WITH = UNKNOWN; /** * @var int * @cvalue T_EXIT diff --git a/ext/tokenizer/tokenizer_data_arginfo.h b/ext/tokenizer/tokenizer_data_arginfo.h index 4363a46720afd..cc28bebaa690e 100644 --- a/ext/tokenizer/tokenizer_data_arginfo.h +++ b/ext/tokenizer/tokenizer_data_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: 1dd42ee5b5b818c5bd131b5c4bbb13c153d99499 */ + * Stub hash: a363f324157f7f10e5784e95d110910f5ade8dcd */ static void register_tokenizer_data_symbols(int module_number) { @@ -29,6 +29,7 @@ static void register_tokenizer_data_symbols(int module_number) REGISTER_LONG_CONSTANT("T_INSTANCEOF", T_INSTANCEOF, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_NEW", T_NEW, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_CLONE", T_CLONE, CONST_PERSISTENT); + REGISTER_LONG_CONSTANT("T_WITH", T_WITH, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_EXIT", T_EXIT, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_IF", T_IF, CONST_PERSISTENT); REGISTER_LONG_CONSTANT("T_ELSEIF", T_ELSEIF, CONST_PERSISTENT);