mirrors/php-src
0
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-11-24 10:24:11 +08:00
Code Issues Packages Projects Releases Wiki Activity
f33b35c2ec
php-src/Zend/zend_inheritance.c

3252 lines
111 KiB
C
Raw Normal View History

Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/*
+----------------------------------------------------------------------+
| Zend Engine |
+----------------------------------------------------------------------+
Adios, yearly copyright ranges
2019-01-30 17:23:29 +08:00
| Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
+----------------------------------------------------------------------+
| This source file is subject to version 2.00 of the Zend license, |
| that is bundled with this package in the file LICENSE, and is |
| available through the world-wide-web at the following url: |
| http://www.zend.com/license/2_00.txt. |
| If you did not receive a copy of the Zend license and are unable to |
| obtain it through the world-wide-web, please send a note to |
| license@zend.com so we can mail you a copy immediately. |
+----------------------------------------------------------------------+
Update email addresses. We're still @Zend, but future proofing it...
2018-11-01 23:20:07 +08:00
| Authors: Andi Gutmans <andi@php.net> |
| Zeev Suraski <zeev@php.net> |
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
+----------------------------------------------------------------------+
*/
#include "zend.h"
#include "zend_API.h"
#include "zend_compile.h"
#include "zend_execute.h"
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
#include "zend_inheritance.h"
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
#include "zend_interfaces.h"
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
#include "zend_smart_str.h"
Fixed bug #74269: Strict comparison of initial trait property values
2017-04-11 04:04:18 +08:00
#include "zend_operators.h"
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
#include "zend_exceptions.h"
Implement enums RFC: https://wiki.php.net/rfc/enumerations Co-authored-by: Nikita Popov <nikita.ppv@gmail.com> Closes GH-6489.
2020-06-11 05:10:18 +08:00
#include "zend_enum.h"
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
#include "zend_attributes.h"
Fix memory leak This fixes oss-fuzz #47088
2022-05-11 16:43:01 +08:00
#include "zend_constants.h"
Add an API to observe functions and classes being linked To observe when the functions and classes start being officially available to the user Signed-off-by: Bob Weinand <bobwei9@hotmail.com>
2022-07-11 22:19:26 +08:00
#include "zend_observer.h"
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
ZEND_API zend_class_entry* (*zend_inheritance_cache_get)(zend_class_entry *ce, zend_class_entry *parent, zend_class_entry **traits_and_interfaces) = NULL;
ZEND_API zend_class_entry* (*zend_inheritance_cache_add)(zend_class_entry *ce, zend_class_entry *proto, zend_class_entry *parent, zend_class_entry **traits_and_interfaces, HashTable *dependencies) = NULL;
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
/* Unresolved means that class declarations that are currently not available are needed to
* determine whether the inheritance is valid or not. At runtime UNRESOLVED should be treated
* as an ERROR. */
typedef enum {
INHERITANCE_UNRESOLVED = -1,
INHERITANCE_ERROR = 0,
INHERITANCE_WARNING = 1,
INHERITANCE_SUCCESS = 2,
} inheritance_status;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
static void add_dependency_obligation(zend_class_entry *ce, zend_class_entry *dependency_ce);
static void add_compatibility_obligation(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_class_entry *ce, const zend_function *child_fn, zend_class_entry *child_scope,
const zend_function *parent_fn, zend_class_entry *parent_scope);
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
static void add_property_compatibility_obligation(
zend_class_entry *ce, const zend_property_info *child_prop,
const zend_property_info *parent_prop);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
static void ZEND_COLD emit_incompatible_method_error(
const zend_function *child, zend_class_entry *child_scope,
const zend_function *parent, zend_class_entry *parent_scope,
inheritance_status status);
Convert some recently introduced zend_bool to bool As well as `scripts/dev/check_parameters.php` utility. Cfr. 3e01f5afb1b52fe26a956190296de0192eedeec1
2021-06-18 19:25:39 +08:00
static void zend_type_copy_ctor(zend_type *type, bool persistent) {
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (ZEND_TYPE_HAS_LIST(*type)) {
zend_type_list *old_list = ZEND_TYPE_LIST(*type);
size_t size = ZEND_TYPE_LIST_SIZE(old_list->num_types);
zend_type_list *new_list = ZEND_TYPE_USES_ARENA(*type)
? zend_arena_alloc(&CG(arena), size) : pemalloc(size, persistent);
memcpy(new_list, old_list, ZEND_TYPE_LIST_SIZE(old_list->num_types));
ZEND_TYPE_SET_PTR(*type, new_list);
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
zend_type *list_type;
ZEND_TYPE_LIST_FOREACH(new_list, list_type) {
ZEND_ASSERT(ZEND_TYPE_HAS_NAME(*list_type));
zend_string_addref(ZEND_TYPE_NAME(*list_type));
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
} ZEND_TYPE_LIST_FOREACH_END();
} else if (ZEND_TYPE_HAS_NAME(*type)) {
zend_string_addref(ZEND_TYPE_NAME(*type));
}
}
Inline hot path
2019-06-27 16:27:53 +08:00
static zend_function *zend_duplicate_internal_function(zend_function *func, zend_class_entry *ce) /* {{{ */
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
{
zend_function *new_function;
Inline hot path
2019-06-27 16:27:53 +08:00
if (UNEXPECTED(ce->type & ZEND_INTERNAL_CLASS)) {
new_function = pemalloc(sizeof(zend_internal_function), 1);
memcpy(new_function, func, sizeof(zend_internal_function));
} else {
new_function = zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
memcpy(new_function, func, sizeof(zend_internal_function));
new_function->common.fn_flags |= ZEND_ACC_ARENA_ALLOCATED;
}
if (EXPECTED(new_function->common.function_name)) {
zend_string_addref(new_function->common.function_name);
}
return new_function;
}
/* }}} */
Don't use separate static variables in inherited methods RFC: https://wiki.php.net/rfc/static_variable_inheritance Closes GH-6719.
2021-02-22 19:28:02 +08:00
static zend_always_inline zend_function *zend_duplicate_function(zend_function *func, zend_class_entry *ce) /* {{{ */
Inline hot path
2019-06-27 16:27:53 +08:00
{
Make fast path linear
2015-03-06 22:07:36 +08:00
if (UNEXPECTED(func->type == ZEND_INTERNAL_FUNCTION)) {
Inline hot path
2019-06-27 16:27:53 +08:00
return zend_duplicate_internal_function(func, ce);
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
} else {
if (func->op_array.refcount) {
(*func->op_array.refcount)++;
}
Store aliased name of trait method Currently, trait methods are aliased will continue to use the original function name. In a few places in the codebase, we will try to look up the actual method name instead. However, this does not work if an aliased method is used indirectly (https://bugs.php.net/bug.php?id=69180). I think it would be better to instead actually change the method name to the alias. This is in principle easy: We have to allow function_name to be changed even if op array is otherwise shared (similar to static_variables). This means we need to addref/release the function_name separately, but I don't think there is a performance concern here (especially as everything is usually interned). There is a bit of complication in opcache, where we need to make sure that the function name is released the correct number of times (interning may overwrite the name in the original op_array, but we need to release it as many times as the op_array is shared). Fixes bug #69180. Fixes bug #74939. Closes GH-5226.
2020-03-02 18:07:57 +08:00
if (EXPECTED(func->op_array.function_name)) {
zend_string_addref(func->op_array.function_name);
}
Don't use separate static variables in inherited methods RFC: https://wiki.php.net/rfc/static_variable_inheritance Closes GH-6719.
2021-02-22 19:28:02 +08:00
return func;
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
}
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
zend_class_entry *parent = ce->parent;
ZEND_ASSERT(parent != NULL);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* You cannot change create_object */
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->create_object = parent->create_object;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* Inherit special functions if needed */
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->get_iterator)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->get_iterator = parent->get_iterator;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__get)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__get = parent->__get;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__set)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__set = parent->__set;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__unset)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__unset = parent->__unset;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__isset)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__isset = parent->__isset;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__call)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__call = parent->__call;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__callstatic)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__callstatic = parent->__callstatic;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__tostring)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__tostring = parent->__tostring;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->clone)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->clone = parent->clone;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Cache __unserialize() instead of unserialize() We should use these cache slots for the new object serialization mechanism rather than the old one.
2020-06-26 16:54:40 +08:00
if (EXPECTED(!ce->__serialize)) {
ce->__serialize = parent->__serialize;
}
if (EXPECTED(!ce->__unserialize)) {
ce->__unserialize = parent->__unserialize;
Assign (un)serialize_func during compilation This avoids writing this cache at runtime, which is illegal if preloading is used. Not every serialize/unserialize function actually belongs to the Serializable interface, but I think it's not a problem to assign these anyway -- whether they are used ultimately depends on whether Serializable is implemented. Alternatively it might make sense to just drop these entirely. I don't think this is performance critical functionality.
2019-02-15 18:20:28 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->serialize)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->serialize = parent->serialize;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->unserialize)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->unserialize = parent->unserialize;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
if (!ce->destructor) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->destructor = parent->destructor;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(!ce->__debugInfo)) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->__debugInfo = parent->__debugInfo;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (ce->constructor) {
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
if (parent->constructor && UNEXPECTED(parent->constructor->common.fn_flags & ZEND_ACC_FINAL)) {
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
zend_error_noreturn(E_ERROR, "Cannot override final %s::%s() with %s::%s()",
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ZSTR_VAL(parent->name), ZSTR_VAL(parent->constructor->common.function_name),
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
ZSTR_VAL(ce->name), ZSTR_VAL(ce->constructor->common.function_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
return;
}
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
ce->constructor = parent->constructor;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
char *zend_visibility_string(uint32_t fn_flags) /* {{{ */
{
if (fn_flags & ZEND_ACC_PUBLIC) {
return "public";
Squashed commit of the following: commit 2d3cac9e005d6bef9aa73ab57cc674aa53125954 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:54:47 2018 +0300 Fixed static property access commit 31786ee27282f319f3ef2a07635b1f325cbd67c6 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 11:05:29 2018 +0300 Avoid duplicate checks commit 5ae502b979ea33d058d01a9421eec5afd0084e8d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 10:39:17 2018 +0300 Optimization commit 82c17f0e8af02c9cf7d1bbdae4e3158330148203 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:26:50 2018 +0300 Removed unused zend_duplicate_property_info() commit ba53d1d0dd91d5530328a11cac93ff9e75c462b5 Merge: eacc11b8fd c4b14370cf Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Sep 11 09:24:13 2018 +0300 Merge branch 'master' into shadow * master: 7.0.33 next Sync NEWS [ci skip] add NEWS for 76582 Enforce ordering of property compare in object comparisons Fixed wrong assertion Skip test on unsuitable env commit eacc11b8fdeb002ee6a149defd8b5a8c3412896a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 13:12:39 2018 +0300 Fixed failure of ext/spl/tests/array_017.phpt commit 62d1871430a1b81c84b790460afff0682648689a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 11:55:07 2018 +0300 Fixed issues commit 1d37e3a40e4d07c4b933ed6f9d2e649dd01180f0 Merge: d6c3f098b6 1e550e6f7e Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Sep 10 10:21:20 2018 +0300 Merge branch 'master' into shadow * master: Update NEWS Fix for bug #76582 Fix ssl stream reneg limit test to print only after first renegotiation Make a copy unconditionally Fix memory leak in pcre cache Remove not needed checking for <errno.h> Remove HAVE_ASSERT_H Add test for bug #76850 Fixed bug #76850 Exit code mangled by set locale/preg_match Remove empty PHP tags from test Fix #75273: php_zlib_inflate_filter() may not update bytes_consumed Fix PCRE2 exclusion and remove dead libs in Makefile.gcov Report mem leaks to stderr if no Win debugger is present Use combined assignment contanation operator Fixed bug #76796 Support fixed address mmap without replacement commit d6c3f098b6015e76d042691de0af2e1426c66829 Author: Dmitry Stogov <dmitry@zend.com> Date: Fri Sep 7 13:56:30 2018 +0300 Get rid of ZEND_ACC_SHADOW
2018-09-11 16:56:45 +08:00
} else if (fn_flags & ZEND_ACC_PRIVATE) {
return "private";
} else {
ZEND_ASSERT(fn_flags & ZEND_ACC_PROTECTED);
return "protected";
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
static zend_string *resolve_class_name(zend_class_entry *scope, zend_string *name) {
ZEND_ASSERT(scope);
if (zend_string_equals_literal_ci(name, "parent") && scope->parent) {
if (scope->ce_flags & ZEND_ACC_RESOLVED_PARENT) {
return scope->parent->name;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
} else {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return scope->parent_name;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
Refactor inheritance type check implementation Extract the self/parent name resolution code and drop unnecessary string copies/releases. Store the fe/proto types in local variables.
2019-05-08 18:11:12 +08:00
} else if (zend_string_equals_literal_ci(name, "self")) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return scope->name;
Refactor inheritance type check implementation Extract the self/parent name resolution code and drop unnecessary string copies/releases. Store the fe/proto types in local variables.
2019-05-08 18:11:12 +08:00
} else {
return name;
Covariance on inheriting classes with iterable
2016-06-04 22:44:49 +08:00
}
}
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
static bool class_visible(zend_class_entry *ce) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
if (ce->type == ZEND_INTERNAL_CLASS) {
return !(CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES);
} else {
ZEND_ASSERT(ce->type == ZEND_USER_CLASS);
return !(CG(compiler_options) & ZEND_COMPILE_IGNORE_OTHER_FILES)
|| ce->info.user.filename == CG(compiled_filename);
}
}
Add reproducer for possible issue with object return type inheritance (#6961) Fix early inheritance Co-authored-by: Joe Watkins <krakjoe@php.net>
2021-05-10 18:52:59 +08:00
static zend_always_inline void register_unresolved_class(zend_string *name) {
/* We'll autoload this class and process delayed variance obligations later. */
if (!CG(delayed_autoloads)) {
ALLOC_HASHTABLE(CG(delayed_autoloads));
zend_hash_init(CG(delayed_autoloads), 0, NULL, NULL, 0);
}
zend_hash_add_empty_element(CG(delayed_autoloads), name);
}
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
static zend_class_entry *lookup_class_ex(
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
zend_class_entry *scope, zend_string *name, bool register_unresolved) {
Add reproducer for possible issue with object return type inheritance (#6961) Fix early inheritance Co-authored-by: Joe Watkins <krakjoe@php.net>
2021-05-10 18:52:59 +08:00
zend_class_entry *ce;
Set EG(active)=0 during preloading shutdown Just like during normal shutdown, we should set EG(active)=0 during the partial preloading shutdown, to make sure that no user code can run. We need to slightly tweak inheritance class loading to still pick the right code path.
2021-08-16 21:53:12 +08:00
bool in_preload = CG(compiler_options) & ZEND_COMPILE_PRELOAD;
Add reproducer for possible issue with object return type inheritance (#6961) Fix early inheritance Co-authored-by: Joe Watkins <krakjoe@php.net>
2021-05-10 18:52:59 +08:00
Set EG(active)=0 during preloading shutdown Just like during normal shutdown, we should set EG(active)=0 during the partial preloading shutdown, to make sure that no user code can run. We need to slightly tweak inheritance class loading to still pick the right code path.
2021-08-16 21:53:12 +08:00
if (UNEXPECTED(!EG(active) && !in_preload)) {
Add reproducer for possible issue with object return type inheritance (#6961) Fix early inheritance Co-authored-by: Joe Watkins <krakjoe@php.net>
2021-05-10 18:52:59 +08:00
zend_string *lc_name = zend_string_tolower(name);
ce = zend_hash_find_ptr(CG(class_table), lc_name);
zend_string_release(lc_name);
if (register_unresolved && !ce) {
zend_error_noreturn(
E_COMPILE_ERROR, "%s must be registered before %s",
ZSTR_VAL(name), ZSTR_VAL(scope->name));
}
return ce;
}
ce = zend_lookup_class_ex(
name, NULL, ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD);
Set EG(active)=0 during preloading shutdown Just like during normal shutdown, we should set EG(active)=0 during the partial preloading shutdown, to make sure that no user code can run. We need to slightly tweak inheritance class loading to still pick the right code path.
2021-08-16 21:53:12 +08:00
if (!CG(in_compilation) || in_preload) {
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
if (ce) {
return ce;
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (register_unresolved) {
Add reproducer for possible issue with object return type inheritance (#6961) Fix early inheritance Co-authored-by: Joe Watkins <krakjoe@php.net>
2021-05-10 18:52:59 +08:00
register_unresolved_class(name);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
} else {
if (ce && class_visible(ce)) {
return ce;
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
/* The current class may not be registered yet, so check for it explicitly. */
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
if (zend_string_equals_ci(scope->name, name)) {
return scope;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
return NULL;
}
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
static zend_class_entry *lookup_class(zend_class_entry *scope, zend_string *name) {
return lookup_class_ex(scope, name, /* register_unresolved */ false);
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
/* Instanceof that's safe to use on unlinked classes. */
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
static bool unlinked_instanceof(zend_class_entry *ce1, zend_class_entry *ce2) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
if (ce1 == ce2) {
return 1;
}
Remove recursive check from instanceof_interface Parent interfaces are copied into the interface list during inheritance, so there's no need to perform a recursive check. Only exception are instanceof checks performed during inheritance itself. However, we already have unlinked_instanceof for this purpose, it just needs to be taught to handle this case. Closes GH-4857.
2019-10-25 00:11:41 +08:00
if (ce1->ce_flags & ZEND_ACC_LINKED) {
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
return instanceof_function(ce1, ce2);
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
Fix bug #80126 When performing an unlinked instanceof, we also need to consider interfaces of parent classes, as they may not have been inherited yet.
2020-10-06 22:30:58 +08:00
if (ce1->parent) {
zend_class_entry *parent_ce;
if (ce1->ce_flags & ZEND_ACC_RESOLVED_PARENT) {
parent_ce = ce1->parent;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
} else {
Fix bug #80126 When performing an unlinked instanceof, we also need to consider interfaces of parent classes, as they may not have been inherited yet.
2020-10-06 22:30:58 +08:00
parent_ce = zend_lookup_class_ex(ce1->parent_name, NULL,
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD);
}
Fix bug #80126 When performing an unlinked instanceof, we also need to consider interfaces of parent classes, as they may not have been inherited yet.
2020-10-06 22:30:58 +08:00
/* It's not sufficient to only check the parent chain itself, as need to do a full
* recursive instanceof in case the parent interfaces haven't been copied yet. */
if (parent_ce && unlinked_instanceof(parent_ce, ce2)) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
return 1;
}
}
if (ce1->num_interfaces) {
uint32_t i;
Remove recursive check from instanceof_interface Parent interfaces are copied into the interface list during inheritance, so there's no need to perform a recursive check. Only exception are instanceof checks performed during inheritance itself. However, we already have unlinked_instanceof for this purpose, it just needs to be taught to handle this case. Closes GH-4857.
2019-10-25 00:11:41 +08:00
if (ce1->ce_flags & ZEND_ACC_RESOLVED_INTERFACES) {
/* Unlike the normal instanceof_function(), we have to perform a recursive
* check here, as the parent interfaces might not have been fully copied yet. */
for (i = 0; i < ce1->num_interfaces; i++) {
if (unlinked_instanceof(ce1->interfaces[i], ce2)) {
return 1;
}
}
} else {
for (i = 0; i < ce1->num_interfaces; i++) {
Fix bug #80126 When performing an unlinked instanceof, we also need to consider interfaces of parent classes, as they may not have been inherited yet.
2020-10-06 22:30:58 +08:00
zend_class_entry *ce = zend_lookup_class_ex(
Remove recursive check from instanceof_interface Parent interfaces are copied into the interface list during inheritance, so there's no need to perform a recursive check. Only exception are instanceof checks performed during inheritance itself. However, we already have unlinked_instanceof for this purpose, it just needs to be taught to handle this case. Closes GH-4857.
2019-10-25 00:11:41 +08:00
ce1->interface_names[i].name, ce1->interface_names[i].lc_name,
ZEND_FETCH_CLASS_ALLOW_UNLINKED | ZEND_FETCH_CLASS_NO_AUTOLOAD);
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
/* Avoid recursing if class implements itself. */
Fix infinite recursion in unlinked_instanceof I suspect this is only a partial fix for the issue, it's probably possible to recurse through a more complex pathway as well. Fixes oss-fuzz #28961.
2021-01-05 20:02:30 +08:00
if (ce && ce != ce1 && unlinked_instanceof(ce, ce2)) {
Remove recursive check from instanceof_interface Parent interfaces are copied into the interface list during inheritance, so there's no need to perform a recursive check. Only exception are instanceof checks performed during inheritance itself. However, we already have unlinked_instanceof for this purpose, it just needs to be taught to handle this case. Closes GH-4857.
2019-10-25 00:11:41 +08:00
return 1;
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
}
}
return 0;
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
}
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
static bool zend_type_permits_self(
Add static return type RFC: https://wiki.php.net/rfc/static_return_type The "static" type is represented as MAY_BE_STATIC, rather than a class type like "self" and "parent", as it has special resolution semantics, and cannot be cached in the runtime cache. Closes GH-5062.
2020-01-07 22:06:36 +08:00
zend_type type, zend_class_entry *scope, zend_class_entry *self) {
if (ZEND_TYPE_FULL_MASK(type) & MAY_BE_OBJECT) {
return 1;
}
/* Any types that may satisfy self must have already been loaded at this point
* (as a parent or interface), so we never need to register delayed variance obligations
* for this case. */
zend_type *single_type;
ZEND_TYPE_FOREACH(type, single_type) {
if (ZEND_TYPE_HAS_NAME(*single_type)) {
zend_string *name = resolve_class_name(scope, ZEND_TYPE_NAME(*single_type));
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
zend_class_entry *ce = lookup_class(self, name);
Add static return type RFC: https://wiki.php.net/rfc/static_return_type The "static" type is represented as MAY_BE_STATIC, rather than a class type like "self" and "parent", as it has special resolution semantics, and cannot be cached in the runtime cache. Closes GH-5062.
2020-01-07 22:06:36 +08:00
if (ce && unlinked_instanceof(self, ce)) {
return 1;
}
}
} ZEND_TYPE_FOREACH_END();
return 0;
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
static void track_class_dependency(zend_class_entry *ce, zend_string *class_name)
{
HashTable *ht;
Add support for Disjoint Normal Form (DNF) types (#8725) RFC: https://wiki.php.net/rfc/dnf_types This allows to combine union and intersection types together in the following form (A&B)|(X&Y)|T but not of the form (X|A)&(Y|B) or (X|A)&(Y|B)|T. * Improve union type parsing Co-authored-by: Sara Golemon <pollita@php.net>
2022-07-08 18:30:23 +08:00
ZEND_ASSERT(class_name);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
if (!CG(current_linking_class) || ce == CG(current_linking_class)) {
return;
} else if (zend_string_equals_literal_ci(class_name, "self")
|| zend_string_equals_literal_ci(class_name, "parent")) {
return;
}
Don't track internal class dependencies Subtyping relationships established on internal classes are always going to hold (if we ignore Windows), so there is no need to explicitly track them. This fixes an assertion failure in GH-7251.
2021-07-19 16:53:22 +08:00
#ifndef ZEND_WIN32
/* On non-Windows systems, internal classes are always the same,
* so there is no need to explicitly track them. */
if (ce->type == ZEND_INTERNAL_CLASS) {
return;
}
#endif
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
ht = (HashTable*)CG(current_linking_class)->inheritance_cache;
if (!(ce->ce_flags & ZEND_ACC_IMMUTABLE)) {
// TODO: dependency on not-immutable class ???
if (ht) {
zend_hash_destroy(ht);
FREE_HASHTABLE(ht);
CG(current_linking_class)->inheritance_cache = NULL;
}
CG(current_linking_class)->ce_flags &= ~ZEND_ACC_CACHEABLE;
CG(current_linking_class) = NULL;
return;
}
/* Record dependency */
if (!ht) {
ALLOC_HASHTABLE(ht);
zend_hash_init(ht, 0, NULL, NULL, 0);
CG(current_linking_class)->inheritance_cache = (zend_inheritance_cache_entry*)ht;
}
zend_hash_add_ptr(ht, class_name, ce);
}
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
/* Check whether any type in the fe_type intersection type is a subtype of the proto class. */
static inheritance_status zend_is_intersection_subtype_of_class(
zend_class_entry *fe_scope, zend_type fe_type,
zend_class_entry *proto_scope, zend_string *proto_class_name, zend_class_entry *proto_ce)
{
ZEND_ASSERT(ZEND_TYPE_IS_INTERSECTION(fe_type));
bool have_unresolved = false;
zend_type *single_type;
/* Traverse the list of child types and check that at least one is
* a subtype of the parent type being checked */
ZEND_TYPE_FOREACH(fe_type, single_type) {
zend_class_entry *fe_ce;
zend_string *fe_class_name = NULL;
if (ZEND_TYPE_HAS_NAME(*single_type)) {
fe_class_name =
resolve_class_name(fe_scope, ZEND_TYPE_NAME(*single_type));
if (zend_string_equals_ci(fe_class_name, proto_class_name)) {
return INHERITANCE_SUCCESS;
}
if (!proto_ce) proto_ce = lookup_class(proto_scope, proto_class_name);
fe_ce = lookup_class(fe_scope, fe_class_name);
} else {
/* standard type in an intersection type is impossible,
* because it would be a fatal compile error */
ZEND_UNREACHABLE();
continue;
}
if (!fe_ce || !proto_ce) {
have_unresolved = true;
continue;
}
if (unlinked_instanceof(fe_ce, proto_ce)) {
track_class_dependency(fe_ce, fe_class_name);
track_class_dependency(proto_ce, proto_class_name);
return INHERITANCE_SUCCESS;
}
} ZEND_TYPE_FOREACH_END();
return have_unresolved ? INHERITANCE_UNRESOLVED : INHERITANCE_ERROR;
}
/* Check whether a single class proto type is a subtype of a potentially complex fe_type. */
static inheritance_status zend_is_class_subtype_of_type(
Always use CE_CACHE, remove TYPE_HAS_CE (#7336) Currently, CE_CACHE on strings is only used with opcache interned strings. This patch extends usage to non-opcache interned strings as well. This means that most type strings can now make use of CE_CACHE even if opcache is not loaded, which allows us to remove TYPE_HAS_CE kind, and fix some discrepancies depending on whether a type stores a resolved or non-resolved name. There are two cases where CE_CACHE will not be used: * When opcache is not used and a permanent interned string (that is not an internal class name) is used as a type name during the request. In this case we can't allocate a map_ptr index for the permanent string, as it would be not be in the permanent map_ptr index space. * When opcache is used but the script is not cached (e.g. eval'd code or opcache full). If opcache is used, we can't allocate additional map_ptr indexes at runtime, because they may conflict with indexes allocated by opcache. In these two cases we would end up not using CE caching for property types (argument/return types still have the separate cache slot).
2021-08-11 16:28:52 +08:00
zend_class_entry *fe_scope, zend_string *fe_class_name,
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
zend_class_entry *proto_scope, zend_type proto_type) {
Always use CE_CACHE, remove TYPE_HAS_CE (#7336) Currently, CE_CACHE on strings is only used with opcache interned strings. This patch extends usage to non-opcache interned strings as well. This means that most type strings can now make use of CE_CACHE even if opcache is not loaded, which allows us to remove TYPE_HAS_CE kind, and fix some discrepancies depending on whether a type stores a resolved or non-resolved name. There are two cases where CE_CACHE will not be used: * When opcache is not used and a permanent interned string (that is not an internal class name) is used as a type name during the request. In this case we can't allocate a map_ptr index for the permanent string, as it would be not be in the permanent map_ptr index space. * When opcache is used but the script is not cached (e.g. eval'd code or opcache full). If opcache is used, we can't allocate additional map_ptr indexes at runtime, because they may conflict with indexes allocated by opcache. In these two cases we would end up not using CE caching for property types (argument/return types still have the separate cache slot).
2021-08-11 16:28:52 +08:00
zend_class_entry *fe_ce = NULL;
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
bool have_unresolved = 0;
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
/* If the parent has 'object' as a return type, any class satisfies the co-variant check */
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (ZEND_TYPE_FULL_MASK(proto_type) & MAY_BE_OBJECT) {
/* Currently, any class name would be allowed here. We still perform a class lookup
* for forward-compatibility reasons, as we may have named types in the future that
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
* are not classes (such as typedefs). */
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (!fe_ce) {
have_unresolved = 1;
} else {
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
track_class_dependency(fe_ce, fe_class_name);
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
return INHERITANCE_SUCCESS;
}
Deduplicate inheritance type check implementation Make the check covariant (insofar as it is allowed now, i.e. nullability and iterable) and call it with appropriate argument order for both parameter and return types. This makes it simpler to extend to full variance support.
2019-05-08 17:24:08 +08:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
zend_type *single_type;
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
/* Traverse the list of parent types and check if the current child (FE)
* class is the subtype of at least one of them (union) or all of them (intersection). */
bool is_intersection = ZEND_TYPE_IS_INTERSECTION(proto_type);
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
ZEND_TYPE_FOREACH(proto_type, single_type) {
Add support for Disjoint Normal Form (DNF) types (#8725) RFC: https://wiki.php.net/rfc/dnf_types This allows to combine union and intersection types together in the following form (A&B)|(X&Y)|T but not of the form (X|A)&(Y|B) or (X|A)&(Y|B)|T. * Improve union type parsing Co-authored-by: Sara Golemon <pollita@php.net>
2022-07-08 18:30:23 +08:00
if (ZEND_TYPE_IS_INTERSECTION(*single_type)) {
inheritance_status subtype_status = zend_is_class_subtype_of_type(
fe_scope, fe_class_name, proto_scope, *single_type);
switch (subtype_status) {
case INHERITANCE_ERROR:
if (is_intersection) {
return INHERITANCE_ERROR;
}
continue;
case INHERITANCE_UNRESOLVED:
have_unresolved = 1;
continue;
case INHERITANCE_SUCCESS:
if (!is_intersection) {
return INHERITANCE_SUCCESS;
}
continue;
EMPTY_SWITCH_DEFAULT_CASE();
}
}
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
zend_class_entry *proto_ce;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
zend_string *proto_class_name = NULL;
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
if (ZEND_TYPE_HAS_NAME(*single_type)) {
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
proto_class_name =
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
resolve_class_name(proto_scope, ZEND_TYPE_NAME(*single_type));
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (zend_string_equals_ci(fe_class_name, proto_class_name)) {
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
if (!is_intersection) {
return INHERITANCE_SUCCESS;
}
continue;
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
}
Refactor inheritance type check implementation Extract the self/parent name resolution code and drop unnecessary string copies/releases. Store the fe/proto types in local variables.
2019-05-08 18:11:12 +08:00
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
if (!fe_ce) fe_ce = lookup_class(fe_scope, fe_class_name);
proto_ce = lookup_class(proto_scope, proto_class_name);
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
} else {
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
/* standard type */
ZEND_ASSERT(!is_intersection);
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
continue;
}
if (!fe_ce || !proto_ce) {
have_unresolved = 1;
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
continue;
}
if (unlinked_instanceof(fe_ce, proto_ce)) {
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
track_class_dependency(fe_ce, fe_class_name);
track_class_dependency(proto_ce, proto_class_name);
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
if (!is_intersection) {
return INHERITANCE_SUCCESS;
}
} else {
if (is_intersection) {
return INHERITANCE_ERROR;
}
Use zend_type inside type lists Instead of having a completely independent encoding for type list entries. This is going to use more memory, but I'm not particularly concerned about that, as type unions that contain multiple classes should be uncommon. On the other hand, this allows us to treat top-level types and types inside lists mostly the same. A new ZEND_TYPE_FOREACH macros allows to transparently treat list and non-list types the same way. I'm not using it everywhere it could be used for now, just the places that seemed most obvious. Of course, this will make any future type system changes much simpler, as it will not be necessary to duplicate all logic two times.
2020-01-17 00:04:11 +08:00
}
} ZEND_TYPE_FOREACH_END();
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
if (have_unresolved) {
return INHERITANCE_UNRESOLVED;
}
return is_intersection ? INHERITANCE_SUCCESS : INHERITANCE_ERROR;
}
Always use CE_CACHE, remove TYPE_HAS_CE (#7336) Currently, CE_CACHE on strings is only used with opcache interned strings. This patch extends usage to non-opcache interned strings as well. This means that most type strings can now make use of CE_CACHE even if opcache is not loaded, which allows us to remove TYPE_HAS_CE kind, and fix some discrepancies depending on whether a type stores a resolved or non-resolved name. There are two cases where CE_CACHE will not be used: * When opcache is not used and a permanent interned string (that is not an internal class name) is used as a type name during the request. In this case we can't allocate a map_ptr index for the permanent string, as it would be not be in the permanent map_ptr index space. * When opcache is used but the script is not cached (e.g. eval'd code or opcache full). If opcache is used, we can't allocate additional map_ptr indexes at runtime, because they may conflict with indexes allocated by opcache. In these two cases we would end up not using CE caching for property types (argument/return types still have the separate cache slot).
2021-08-11 16:28:52 +08:00
static zend_string *get_class_from_type(zend_class_entry *scope, zend_type single_type) {
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
if (ZEND_TYPE_HAS_NAME(single_type)) {
return resolve_class_name(scope, ZEND_TYPE_NAME(single_type));
}
return NULL;
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
}
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
static void register_unresolved_classes(zend_class_entry *scope, zend_type type) {
zend_type *single_type;
ZEND_TYPE_FOREACH(type, single_type) {
Add support for Disjoint Normal Form (DNF) types (#8725) RFC: https://wiki.php.net/rfc/dnf_types This allows to combine union and intersection types together in the following form (A&B)|(X&Y)|T but not of the form (X|A)&(Y|B) or (X|A)&(Y|B)|T. * Improve union type parsing Co-authored-by: Sara Golemon <pollita@php.net>
2022-07-08 18:30:23 +08:00
if (ZEND_TYPE_HAS_LIST(*single_type)) {
register_unresolved_classes(scope, *single_type);
continue;
}
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
if (ZEND_TYPE_HAS_NAME(*single_type)) {
zend_string *class_name = resolve_class_name(scope, ZEND_TYPE_NAME(*single_type));
lookup_class_ex(scope, class_name, /* register_unresolved */ true);
}
} ZEND_TYPE_FOREACH_END();
}
Add support for Disjoint Normal Form (DNF) types (#8725) RFC: https://wiki.php.net/rfc/dnf_types This allows to combine union and intersection types together in the following form (A&B)|(X&Y)|T but not of the form (X|A)&(Y|B) or (X|A)&(Y|B)|T. * Improve union type parsing Co-authored-by: Sara Golemon <pollita@php.net>
2022-07-08 18:30:23 +08:00
static inheritance_status zend_is_intersection_subtype_of_type(
zend_class_entry *fe_scope, zend_type fe_type,
zend_class_entry *proto_scope, zend_type proto_type)
{
bool have_unresolved = false;
zend_type *single_type;
uint32_t proto_type_mask = ZEND_TYPE_PURE_MASK(proto_type);
/* Currently, for object type any class name would be allowed here.
* We still perform a class lookup for forward-compatibility reasons,
* as we may have named types in the future that are not classes
* (such as typedefs). */
if (proto_type_mask & MAY_BE_OBJECT) {
ZEND_TYPE_FOREACH(fe_type, single_type) {
zend_string *fe_class_name = get_class_from_type(fe_scope, *single_type);
if (!fe_class_name) {
continue;
}
zend_class_entry *fe_ce = lookup_class(fe_scope, fe_class_name);
if (fe_ce) {
track_class_dependency(fe_ce, fe_class_name);
return INHERITANCE_SUCCESS;
} else {
have_unresolved = true;
}
} ZEND_TYPE_FOREACH_END();
}
/* U_1&...&U_n < V_1&...&V_m if forall V_j. exists U_i. U_i < V_j.
* U_1&...&U_n < V_1|...|V_m if exists V_j. exists U_i. U_i < V_j.
* As such, we need to iterate over proto_type (V_j) first and use a different
* quantifier depending on whether fe_type is a union or an intersection. */
inheritance_status early_exit_status =
ZEND_TYPE_IS_INTERSECTION(proto_type) ? INHERITANCE_ERROR : INHERITANCE_SUCCESS;
ZEND_TYPE_FOREACH(proto_type, single_type) {
inheritance_status status;
if (ZEND_TYPE_IS_INTERSECTION(*single_type)) {
status = zend_is_intersection_subtype_of_type(
fe_scope, fe_type, proto_scope, *single_type);
} else {
zend_string *proto_class_name = get_class_from_type(proto_scope, *single_type);
if (!proto_class_name) {
continue;
}
zend_class_entry *proto_ce = NULL;
status = zend_is_intersection_subtype_of_class(
fe_scope, fe_type, proto_scope, proto_class_name, proto_ce);
}
if (status == early_exit_status) {
return status;
}
if (status == INHERITANCE_UNRESOLVED) {
have_unresolved = true;
}
} ZEND_TYPE_FOREACH_END();
if (have_unresolved) {
return INHERITANCE_UNRESOLVED;
}
return early_exit_status == INHERITANCE_ERROR ? INHERITANCE_SUCCESS : INHERITANCE_ERROR;
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
static inheritance_status zend_perform_covariant_type_check(
zend_class_entry *fe_scope, zend_type fe_type,
Move INHERITANCE_WARNING handling one layer up There is only a single place where we need to convert ERROR into WARNING, don't thread it through more places than necessary.
2021-06-30 21:45:42 +08:00
zend_class_entry *proto_scope, zend_type proto_type)
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
{
ZEND_ASSERT(ZEND_TYPE_IS_SET(fe_type) && ZEND_TYPE_IS_SET(proto_type));
Don't autoload classes during covariant type check against mixed mixed should be behaving the same way as no type here, and not require X to be autoloaded. Everything apart from "void" is trivially covariant to "mixed".
2021-05-10 15:45:48 +08:00
/* Apart from void, everything is trivially covariant to the mixed type.
* Handle this case separately to ensure it never requires class loading. */
if (ZEND_TYPE_PURE_MASK(proto_type) == MAY_BE_ANY &&
!ZEND_TYPE_CONTAINS_CODE(fe_type, IS_VOID)) {
return INHERITANCE_SUCCESS;
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Builtin types may be removed, but not added */
uint32_t fe_type_mask = ZEND_TYPE_PURE_MASK(fe_type);
uint32_t proto_type_mask = ZEND_TYPE_PURE_MASK(proto_type);
uint32_t added_types = fe_type_mask & ~proto_type_mask;
if (added_types) {
Add static return type RFC: https://wiki.php.net/rfc/static_return_type The "static" type is represented as MAY_BE_STATIC, rather than a class type like "self" and "parent", as it has special resolution semantics, and cannot be cached in the runtime cache. Closes GH-5062.
2020-01-07 22:06:36 +08:00
if ((added_types & MAY_BE_STATIC)
&& zend_type_permits_self(proto_type, proto_scope, fe_scope)) {
/* Replacing type that accepts self with static is okay */
added_types &= ~MAY_BE_STATIC;
}
Implement never return type The never type can be used to indicate that a function never returns, for example because it always unwinds. RFC: https://wiki.php.net/rfc/noreturn_type Closes GH-6761.
2021-04-19 17:23:30 +08:00
if (added_types == MAY_BE_NEVER) {
/* never is the bottom type */
return INHERITANCE_SUCCESS;
}
Add static return type RFC: https://wiki.php.net/rfc/static_return_type The "static" type is represented as MAY_BE_STATIC, rather than a class type like "self" and "parent", as it has special resolution semantics, and cannot be cached in the runtime cache. Closes GH-5062.
2020-01-07 22:06:36 +08:00
if (added_types) {
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Otherwise adding new types is illegal */
Move INHERITANCE_WARNING handling one layer up There is only a single place where we need to convert ERROR into WARNING, don't thread it through more places than necessary.
2021-06-30 21:45:42 +08:00
return INHERITANCE_ERROR;
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
}
}
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
zend_type *single_type;
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
inheritance_status early_exit_status;
bool have_unresolved = false;
if (ZEND_TYPE_IS_INTERSECTION(fe_type)) {
early_exit_status =
ZEND_TYPE_IS_INTERSECTION(proto_type) ? INHERITANCE_ERROR : INHERITANCE_SUCCESS;
Add support for Disjoint Normal Form (DNF) types (#8725) RFC: https://wiki.php.net/rfc/dnf_types This allows to combine union and intersection types together in the following form (A&B)|(X&Y)|T but not of the form (X|A)&(Y|B) or (X|A)&(Y|B)|T. * Improve union type parsing Co-authored-by: Sara Golemon <pollita@php.net>
2022-07-08 18:30:23 +08:00
inheritance_status status = zend_is_intersection_subtype_of_type(
fe_scope, fe_type, proto_scope, proto_type);
Deduplicate inheritance type check implementation Make the check covariant (insofar as it is allowed now, i.e. nullability and iterable) and call it with appropriate argument order for both parameter and return types. This makes it simpler to extend to full variance support.
2019-05-08 17:24:08 +08:00
Add support for Disjoint Normal Form (DNF) types (#8725) RFC: https://wiki.php.net/rfc/dnf_types This allows to combine union and intersection types together in the following form (A&B)|(X&Y)|T but not of the form (X|A)&(Y|B) or (X|A)&(Y|B)|T. * Improve union type parsing Co-authored-by: Sara Golemon <pollita@php.net>
2022-07-08 18:30:23 +08:00
if (status == early_exit_status) {
return status;
}
if (status == INHERITANCE_UNRESOLVED) {
have_unresolved = true;
}
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
} else {
/* U_1|...|U_n < V_1|...|V_m if forall U_i. exists V_j. U_i < V_j.
* U_1|...|U_n < V_1&...&V_m if forall U_i. forall V_j. U_i < V_j.
* We need to iterate over fe_type (U_i) first and the logic is independent of
* whether proto_type is a union or intersection (only the inner check differs). */
early_exit_status = INHERITANCE_ERROR;
ZEND_TYPE_FOREACH(fe_type, single_type) {
Add support for Disjoint Normal Form (DNF) types (#8725) RFC: https://wiki.php.net/rfc/dnf_types This allows to combine union and intersection types together in the following form (A&B)|(X&Y)|T but not of the form (X|A)&(Y|B) or (X|A)&(Y|B)|T. * Improve union type parsing Co-authored-by: Sara Golemon <pollita@php.net>
2022-07-08 18:30:23 +08:00
inheritance_status status;
/* Union has an intersection type as it's member */
if (ZEND_TYPE_IS_INTERSECTION(*single_type)) {
status = zend_is_intersection_subtype_of_type(
fe_scope, *single_type, proto_scope, proto_type);
} else {
zend_string *fe_class_name = get_class_from_type(fe_scope, *single_type);
if (!fe_class_name) {
continue;
}
status = zend_is_class_subtype_of_type(
fe_scope, fe_class_name, proto_scope, proto_type);
Pure Intersection types (#6799) Implement pure intersection types RFC RFC: https://wiki.php.net/rfc/pure-intersection-types Co-authored-by: Nikita Popov <nikic@php.net> Co-authored-by: Ilija Tovilo <ilutov@php.net>
2021-07-05 20:11:03 +08:00
}
if (status == early_exit_status) {
return status;
}
if (status == INHERITANCE_UNRESOLVED) {
have_unresolved = true;
}
} ZEND_TYPE_FOREACH_END();
}
if (!have_unresolved) {
return early_exit_status == INHERITANCE_ERROR ? INHERITANCE_SUCCESS : INHERITANCE_ERROR;
work on #71428
2016-03-28 18:54:25 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
Simplify registration of unresolved classes If we have an UNRESOLVED result, simply register all classes that occur in either of the types. I believe that's equivalent to what we're currently doing in a more complicated way.
2021-07-01 16:12:49 +08:00
register_unresolved_classes(fe_scope, fe_type);
register_unresolved_classes(proto_scope, proto_type);
Fix variance checks on resolved union types This is a bit annoying: When preloading is used, types might be resolved during inheritance checks, so we need to deal with CE types rather than just NAME types everywhere.
2020-11-03 21:15:05 +08:00
return INHERITANCE_UNRESOLVED;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
static inheritance_status zend_do_perform_arg_type_hint_check(
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_class_entry *fe_scope, zend_arg_info *fe_arg_info,
zend_class_entry *proto_scope, zend_arg_info *proto_arg_info) /* {{{ */
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
{
Add support for the mixed type RFC: https://wiki.php.net/rfc/mixed_type_v2 Closes GH-5313 Co-authored-by: Dan Ackroyd <danack@basereality.com>
2020-03-28 06:39:49 +08:00
if (!ZEND_TYPE_IS_SET(fe_arg_info->type) || ZEND_TYPE_PURE_MASK(fe_arg_info->type) == MAY_BE_ANY) {
/* Child with no type or mixed type is always compatible */
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_SUCCESS;
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
}
if (!ZEND_TYPE_IS_SET(proto_arg_info->type)) {
/* Child defines a type, but parent doesn't, violates LSP */
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
}
Deduplicate inheritance type check implementation Make the check covariant (insofar as it is allowed now, i.e. nullability and iterable) and call it with appropriate argument order for both parameter and return types. This makes it simpler to extend to full variance support.
2019-05-08 17:24:08 +08:00
/* Contravariant type check is performed as a covariant type check with swapped
* argument order. */
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
return zend_perform_covariant_type_check(
Move INHERITANCE_WARNING handling one layer up There is only a single place where we need to convert ERROR into WARNING, don't thread it through more places than necessary.
2021-06-30 21:45:42 +08:00
proto_scope, proto_arg_info->type, fe_scope, fe_arg_info->type);
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
}
/* }}} */
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
/* For trait methods, fe_scope/proto_scope may differ from fe/proto->common.scope,
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
* as self will refer to the self of the class the trait is used in, not the trait
* the method was declared in. */
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
static inheritance_status zend_do_perform_implementation_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
const zend_function *fe, zend_class_entry *fe_scope,
const zend_function *proto, zend_class_entry *proto_scope) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
uint32_t i, num_args, proto_num_args, fe_num_args;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
inheritance_status status, local_status;
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
bool proto_is_variadic, fe_is_variadic;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* Checks for constructors only if they are declared in an interface,
* or explicitly marked as abstract
*/
Replace previosly checked conditions by ZEND_ASSERT()
2019-06-25 23:26:56 +08:00
ZEND_ASSERT(!((fe->common.fn_flags & ZEND_ACC_CTOR)
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
&& ((proto->common.scope->ce_flags & ZEND_ACC_INTERFACE) == 0
Replace previosly checked conditions by ZEND_ASSERT()
2019-06-25 23:26:56 +08:00
&& (proto->common.fn_flags & ZEND_ACC_ABSTRACT) == 0)));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
/* If the prototype method is private and not abstract, we do not enforce a signature.
* private abstract methods can only occur in traits. */
ZEND_ASSERT(!(proto->common.fn_flags & ZEND_ACC_PRIVATE)
|| (proto->common.fn_flags & ZEND_ACC_ABSTRACT));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
/* The number of required arguments cannot increase. */
if (proto->common.required_num_args < fe->common.required_num_args) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* by-ref constraints on return values are covariant */
if ((proto->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)
&& !(fe->common.fn_flags & ZEND_ACC_RETURN_REFERENCE)) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
proto_is_variadic = (proto->common.fn_flags & ZEND_ACC_VARIADIC) != 0;
fe_is_variadic = (fe->common.fn_flags & ZEND_ACC_VARIADIC) != 0;
/* A variadic function cannot become non-variadic */
if (proto_is_variadic && !fe_is_variadic) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
/* The variadic argument is not included in the stored argument count. */
proto_num_args = proto->common.num_args + proto_is_variadic;
fe_num_args = fe->common.num_args + fe_is_variadic;
num_args = MAX(proto_num_args, fe_num_args);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
status = INHERITANCE_SUCCESS;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
for (i = 0; i < num_args; i++) {
Allow variadic arguments to replace non-variadic ones Any number of arguments can be replaced by a variadic one, so long as the variadic argument is compatible (in the sense of contravariance) with the subsumed arguments. In particular this means that function(...$args) becomes a near-universal signature: It is compatible with any function signature that does not accept parameters by-reference. This also fixes bug #70839, which describes a special case. Closes GH-5059.
2020-01-06 19:06:51 +08:00
zend_arg_info *proto_arg_info =
i < proto_num_args ? &proto->common.arg_info[i] :
proto_is_variadic ? &proto->common.arg_info[proto_num_args - 1] : NULL;
zend_arg_info *fe_arg_info =
i < fe_num_args ? &fe->common.arg_info[i] :
fe_is_variadic ? &fe->common.arg_info[fe_num_args - 1] : NULL;
if (!proto_arg_info) {
/* A new (optional) argument has been added, which is fine. */
continue;
}
if (!fe_arg_info) {
/* An argument has been removed. This is considered illegal, because arity checks
* work based on a model where passing more than the declared number of parameters
* to a function is an error. */
return INHERITANCE_ERROR;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
local_status = zend_do_perform_arg_type_hint_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
fe_scope, fe_arg_info, proto_scope, proto_arg_info);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
if (UNEXPECTED(local_status != INHERITANCE_SUCCESS)) {
if (UNEXPECTED(local_status == INHERITANCE_ERROR)) {
return INHERITANCE_ERROR;
}
ZEND_ASSERT(local_status == INHERITANCE_UNRESOLVED);
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
status = INHERITANCE_UNRESOLVED;
Fixed bug #71978 (Existence of return type hint affects other compatibility rules)
2016-04-06 22:17:10 +08:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
/* by-ref constraints on arguments are invariant */
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (ZEND_ARG_SEND_MODE(fe_arg_info) != ZEND_ARG_SEND_MODE(proto_arg_info)) {
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return INHERITANCE_ERROR;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Allow adding return type during inheritance This is allowed as per the return types RFC. The test for this behavior happened to use an internal class without arginfo, which is why this was not properly implemented.
2015-03-23 01:50:36 +08:00
/* Check return type compatibility, but only if the prototype already specifies
* a return type. Adding a new return type is always valid. */
if (proto->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
/* Removing a return type is not valid, unless the parent return type is tentative. */
Allow adding return type during inheritance This is allowed as per the return types RFC. The test for this behavior happened to use an internal class without arginfo, which is why this was not properly implemented.
2015-03-23 01:50:36 +08:00
if (!(fe->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE)) {
Don't directly throw warning during method compatibility check Only return the INHERITANCE_WARNING status.
2021-05-17 16:16:47 +08:00
if (!ZEND_ARG_TYPE_IS_TENTATIVE(&proto->common.arg_info[-1])) {
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
return INHERITANCE_ERROR;
}
Don't directly throw warning during method compatibility check Only return the INHERITANCE_WARNING status.
2021-05-17 16:16:47 +08:00
if (status == INHERITANCE_SUCCESS) {
return INHERITANCE_WARNING;
}
return status;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
Implement Parameter Type Widening RFC
2017-01-01 22:53:24 +08:00
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
local_status = zend_perform_covariant_type_check(
Move INHERITANCE_WARNING handling one layer up There is only a single place where we need to convert ERROR into WARNING, don't thread it through more places than necessary.
2021-06-30 21:45:42 +08:00
fe_scope, fe->common.arg_info[-1].type, proto_scope, proto->common.arg_info[-1].type);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
if (UNEXPECTED(local_status != INHERITANCE_SUCCESS)) {
Move INHERITANCE_WARNING handling one layer up There is only a single place where we need to convert ERROR into WARNING, don't thread it through more places than necessary.
2021-06-30 21:45:42 +08:00
if (local_status == INHERITANCE_ERROR
&& ZEND_ARG_TYPE_IS_TENTATIVE(&proto->common.arg_info[-1])) {
local_status = INHERITANCE_WARNING;
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
}
Move INHERITANCE_WARNING handling one layer up There is only a single place where we need to convert ERROR into WARNING, don't thread it through more places than necessary.
2021-06-30 21:45:42 +08:00
return local_status;
Implement nullable return types.
2016-04-06 23:24:34 +08:00
}
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
return status;
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
/* }}} */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
static ZEND_COLD void zend_append_type_hint(
Improve type declarations for Zend APIs Voidification of Zend API which always succeeded Use bool argument types instead of int for boolean arguments Use bool return type for functions which return true/false (1/0) Use zend_result return type for functions which return SUCCESS/FAILURE as they don't follow normal boolean semantics Closes GH-6002
2020-08-28 21:41:27 +08:00
smart_str *str, zend_class_entry *scope, zend_arg_info *arg_info, bool return_hint) /* {{{ */
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
{
Change representation of zend_type from type code to MAY_BE_* mask This switches zend_type from storing a single IS_* type code to storing a MAY_BE_* type mask. Right now most code still assumes that there is only a single type in the mask (or two together with MAY_BE_NULL). But this will make it a lot simpler to introduce union types. An additional advantage (and why I'm doing this separately), is that a number of special cases no longer need to be handled separately: We can do a single mask & (1 << type) check to handle all simple types, booleans (true|false) and null.
2019-09-19 18:11:29 +08:00
if (ZEND_TYPE_IS_SET(arg_info->type)) {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_string *type_str = zend_type_to_string_resolved(arg_info->type, scope);
Change representation of zend_type from type code to MAY_BE_* mask This switches zend_type from storing a single IS_* type code to storing a MAY_BE_* type mask. Right now most code still assumes that there is only a single type in the mask (or two together with MAY_BE_NULL). But this will make it a lot simpler to introduce union types. An additional advantage (and why I'm doing this separately), is that a number of special cases no longer need to be handled separately: We can do a single mask & (1 << type) check to handle all simple types, booleans (true|false) and null.
2019-09-19 18:11:29 +08:00
smart_str_append(str, type_str);
zend_string_release(type_str);
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
if (!return_hint) {
smart_str_appendc(str, ' ');
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
}
/* }}} */
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
static ZEND_COLD zend_string *zend_get_function_declaration(
const zend_function *fptr, zend_class_entry *scope) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str str = {0};
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "& ");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
if (fptr->common.scope) {
Use zend_type.ce_cache__ptr for caching class resulution during argument/result type checks
2021-02-10 23:00:00 +08:00
if (fptr->common.scope->ce_flags & ZEND_ACC_ANON_CLASS) {
/* cut off on NULL byte ... class@anonymous */
smart_str_appends(&str, ZSTR_VAL(fptr->common.scope->name));
} else {
smart_str_appendl(&str, ZSTR_VAL(fptr->common.scope->name), ZSTR_LEN(fptr->common.scope->name));
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "::");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Add smart_str_append for appending zend_strings Also replaces usages in Zend/ and ext/standard
2014-09-22 02:47:07 +08:00
smart_str_append(&str, fptr->common.function_name);
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '(');
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (fptr->common.arg_info) {
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 21:44:39 +08:00
uint32_t i, num_args, required;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_arg_info *arg_info = fptr->common.arg_info;
required = fptr->common.required_num_args;
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 21:44:39 +08:00
num_args = fptr->common.num_args;
if (fptr->common.fn_flags & ZEND_ACC_VARIADIC) {
num_args++;
}
for (i = 0; i < num_args;) {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_append_type_hint(&str, scope, arg_info, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (ZEND_ARG_SEND_MODE(arg_info)) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '&');
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (ZEND_ARG_IS_VARIADIC(arg_info)) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "...");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '$');
Assert that arginfo parameter name is present
2020-04-07 22:05:33 +08:00
if (fptr->type == ZEND_INTERNAL_FUNCTION) {
smart_str_appends(&str, ((zend_internal_arg_info*)arg_info)->name);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Assert that arginfo parameter name is present
2020-04-07 22:05:33 +08:00
smart_str_appendl(&str, ZSTR_VAL(arg_info->name), ZSTR_LEN(arg_info->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (i >= required && !ZEND_ARG_IS_VARIADIC(arg_info)) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, " = ");
Store default parameter values of internal functions in arg info Closes GH-5353. From now on, PHP will have reflection information about default values of parameters of internal functions. Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2020-04-06 17:02:13 +08:00
if (fptr->type == ZEND_INTERNAL_FUNCTION) {
if (((zend_internal_arg_info*)arg_info)->default_value) {
smart_str_appends(&str, ((zend_internal_arg_info*)arg_info)->default_value);
} else {
smart_str_appends(&str, "<default>");
}
} else {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_op *precv = NULL;
{
uint32_t idx = i;
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
zend_op *op = fptr->op_array.opcodes;
zend_op *end = op + fptr->op_array.last;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
++idx;
while (op < end) {
if ((op->opcode == ZEND_RECV || op->opcode == ZEND_RECV_INIT)
&& op->op1.num == (zend_ulong)idx)
{
precv = op;
}
++op;
}
}
if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {
Changed the way VM accesses constant operands in 64-bit builds.
2017-10-04 21:53:01 +08:00
zval *zv = RT_CONSTANT(precv, precv->op2);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
if (Z_TYPE_P(zv) == IS_FALSE) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "false");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_TRUE) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "true");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_NULL) {
Improve the default value format in incompatible signature error messages Closes GH-5361
2020-04-09 15:46:44 +08:00
smart_str_appends(&str, "null");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_STRING) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '\'');
smart_str_appendl(&str, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (Z_STRLEN_P(zv) > 10) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, "...");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, '\'');
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_ARRAY) {
Improve the default value format in incompatible signature error messages Closes GH-5361
2020-04-09 15:46:44 +08:00
if (zend_hash_num_elements(Z_ARRVAL_P(zv)) == 0) {
smart_str_appends(&str, "[]");
} else {
smart_str_appends(&str, "[...]");
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else if (Z_TYPE_P(zv) == IS_CONSTANT_AST) {
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
zend_ast *ast = Z_ASTVAL_P(zv);
if (ast->kind == ZEND_AST_CONSTANT) {
smart_str_append(&str, zend_ast_get_constant_name(ast));
Don't evalutae ZEND_AST_CLASS_CONST to ZEND_AST_CONSTANT ar compile-time. Keep at to run-time and use Fast Class Cache during run-time evaluation.
2021-04-09 22:48:28 +08:00
} else if (ast->kind == ZEND_AST_CLASS_CONST) {
smart_str_append(&str, zend_ast_get_str(ast->child[0]));
smart_str_appends(&str, "::");
smart_str_append(&str, zend_ast_get_str(ast->child[1]));
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
} else {
smart_str_appends(&str, "<expression>");
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Avoid unnecessary reference-counting on strings.
2017-11-16 22:09:32 +08:00
zend_string *tmp_zv_str;
zend_string *zv_str = zval_get_tmp_string(zv, &tmp_zv_str);
Add smart_str_append for appending zend_strings Also replaces usages in Zend/ and ext/standard
2014-09-22 02:47:07 +08:00
smart_str_append(&str, zv_str);
Avoid unnecessary reference-counting on strings.
2017-11-16 22:09:32 +08:00
zend_tmp_string_release(tmp_zv_str);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
}
}
Don't count variadic argument in zend_func.common.num_args. This allows faster CALL/RETURN code.
2014-12-22 21:44:39 +08:00
if (++i < num_args) {
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appends(&str, ", ");
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
arg_info++;
}
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_appendc(&str, ')');
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
if (fptr->common.fn_flags & ZEND_ACC_HAS_RETURN_TYPE) {
smart_str_appends(&str, ": ");
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_append_type_hint(&str, scope, fptr->common.arg_info - 1, 1);
Implement return types RFC is documented here: https://wiki.php.net/rfc/return_types
2015-01-09 04:40:36 +08:00
}
Use smart_str in get_function_declaration Instead of custom smart string implementation
2014-09-21 05:27:10 +08:00
smart_str_0(&str);
return str.s;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
static zend_always_inline zend_string *func_filename(const zend_function *fn) {
return fn->common.type == ZEND_USER_FUNCTION ? fn->op_array.filename : NULL;
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
static zend_always_inline uint32_t func_lineno(const zend_function *fn) {
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
return fn->common.type == ZEND_USER_FUNCTION ? fn->op_array.line_start : 0;
}
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
static void ZEND_COLD emit_incompatible_method_error(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
const zend_function *child, zend_class_entry *child_scope,
const zend_function *parent, zend_class_entry *parent_scope,
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
inheritance_status status) {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_string *parent_prototype = zend_get_function_declaration(parent, parent_scope);
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_string *child_prototype = zend_get_function_declaration(child, child_scope);
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
if (status == INHERITANCE_UNRESOLVED) {
Add support for Disjoint Normal Form (DNF) types (#8725) RFC: https://wiki.php.net/rfc/dnf_types This allows to combine union and intersection types together in the following form (A&B)|(X&Y)|T but not of the form (X|A)&(Y|B) or (X|A)&(Y|B)|T. * Improve union type parsing Co-authored-by: Sara Golemon <pollita@php.net>
2022-07-08 18:30:23 +08:00
// TODO Improve error message if first unresolved class is present in child and parent?
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Fetch the first unresolved class from registered autoloads */
zend_string *unresolved_class = NULL;
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY(CG(delayed_autoloads), unresolved_class) {
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
break;
} ZEND_HASH_FOREACH_END();
ZEND_ASSERT(unresolved_class);
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
zend_error_at(E_COMPILE_ERROR, func_filename(child), func_lineno(child),
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
"Could not check compatibility between %s and %s, because class %s is not available",
ZSTR_VAL(child_prototype), ZSTR_VAL(parent_prototype), ZSTR_VAL(unresolved_class));
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
} else if (status == INHERITANCE_WARNING) {
zend_attribute *return_type_will_change_attribute = zend_get_attribute_str(
child->common.attributes,
"returntypewillchange",
sizeof("returntypewillchange")-1
);
if (!return_type_will_change_attribute) {
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
zend_error_at(E_DEPRECATED, func_filename(child), func_lineno(child),
Mention ReturnTypeWillChange attribute in the error message (#7183)
2021-06-28 20:56:21 +08:00
"Return type of %s should either be compatible with %s, "
Fully qualify ReturnTypeWillChange in deprecation message When adding the #[ReturnTypeWillChange] attribute in namespaced code, you also need to use ReturnTypeWillChange, otherwise it will be silently ignored and may result in confusion. Change the deprecation message to suggest #[\ReturnTypeWillChange], which will always work. Closes GH-7454.
2021-09-03 00:38:52 +08:00
"or the #[\\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice",
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
ZSTR_VAL(child_prototype), ZSTR_VAL(parent_prototype));
Convert exception during inheritance to fatal error Now that inheritance can throw deprecations again, these may be converted to exception by a custom error handler. In this case we need to convert the exception to a fatal error, as inheritance cannot safely throw in the general case.
2021-05-28 16:19:23 +08:00
if (EG(exception)) {
zend_exception_uncaught_error(
"During inheritance of %s", ZSTR_VAL(parent_scope->name));
}
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
}
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
} else {
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
zend_error_at(E_COMPILE_ERROR, func_filename(child), func_lineno(child),
Merge branch 'PHP-7.4'
2019-05-24 15:33:58 +08:00
"Declaration of %s must be compatible with %s",
ZSTR_VAL(child_prototype), ZSTR_VAL(parent_prototype));
Implement basic variance support This is a minimal variance implementation: It does not support any cyclic type dependencies. Additionally the preloading requirements are much more restrictive than necessary. Hopefully we can relax these in the future.
2019-05-08 18:30:16 +08:00
}
zend_string_efree(child_prototype);
zend_string_efree(parent_prototype);
}
Cleanup
2019-06-25 21:37:42 +08:00
static void perform_delayable_implementation_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_class_entry *ce,
const zend_function *fe, zend_class_entry *fe_scope,
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
const zend_function *proto, zend_class_entry *proto_scope)
Cleanup
2019-06-25 21:37:42 +08:00
{
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
inheritance_status status =
zend_do_perform_implementation_check(fe, fe_scope, proto, proto_scope);
Cleanup
2019-06-25 21:37:42 +08:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
if (EXPECTED(status == INHERITANCE_UNRESOLVED)) {
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
add_compatibility_obligation(ce, fe, fe_scope, proto, proto_scope);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
} else {
Add support for tentative return types of internal methods RFC: https://wiki.php.net/rfc/internal_method_return_types Closses GH-6971
2021-05-06 21:05:21 +08:00
ZEND_ASSERT(status == INHERITANCE_ERROR || status == INHERITANCE_WARNING);
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
emit_incompatible_method_error(fe, fe_scope, proto, proto_scope, status);
Cleanup
2019-06-25 21:37:42 +08:00
}
}
}
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
static zend_always_inline inheritance_status do_inheritance_check_on_method_ex(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_function *child, zend_class_entry *child_scope,
zend_function *parent, zend_class_entry *parent_scope,
zend_class_entry *ce, zval *child_zv,
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
bool check_visibility, bool check_only, bool checked) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
uint32_t child_flags;
uint32_t parent_flags = parent->common.fn_flags;
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
zend_function *proto;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Ignore inheritance rules on private methods Closes GH-5401
2020-04-17 01:53:13 +08:00
if (UNEXPECTED((parent_flags & ZEND_ACC_PRIVATE) && !(parent_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_CTOR))) {
if (!check_only) {
child->common.fn_flags |= ZEND_ACC_CHANGED;
}
/* The parent method is private and not an abstract so we don't need to check any inheritance rules */
return INHERITANCE_SUCCESS;
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!checked && UNEXPECTED(parent_flags & ZEND_ACC_FINAL)) {
if (check_only) {
return INHERITANCE_ERROR;
}
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, func_filename(child), func_lineno(child),
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
"Cannot override final method %s::%s()",
ZEND_FN_SCOPE_NAME(parent), ZSTR_VAL(child->common.function_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
child_flags = child->common.fn_flags;
/* You cannot change from static to non static and vice versa.
*/
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!checked && UNEXPECTED((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC))) {
if (check_only) {
return INHERITANCE_ERROR;
}
Avoid reloading
2018-07-09 21:28:13 +08:00
if (child_flags & ZEND_ACC_STATIC) {
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, func_filename(child), func_lineno(child),
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
"Cannot make non static method %s::%s() static in class %s",
ZEND_FN_SCOPE_NAME(parent), ZSTR_VAL(child->common.function_name), ZEND_FN_SCOPE_NAME(child));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, func_filename(child), func_lineno(child),
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
"Cannot make static method %s::%s() non static in class %s",
ZEND_FN_SCOPE_NAME(parent), ZSTR_VAL(child->common.function_name), ZEND_FN_SCOPE_NAME(child));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* Disallow making an inherited method abstract. */
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!checked && UNEXPECTED((child_flags & ZEND_ACC_ABSTRACT) > (parent_flags & ZEND_ACC_ABSTRACT))) {
if (check_only) {
return INHERITANCE_ERROR;
}
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, func_filename(child), func_lineno(child),
Fix lineno for more inheritance errors And also include explicit linenos in tests.
2019-03-27 20:02:28 +08:00
"Cannot make non abstract method %s::%s() abstract in class %s",
ZEND_FN_SCOPE_NAME(parent), ZSTR_VAL(child->common.function_name), ZEND_FN_SCOPE_NAME(child));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!check_only && (parent_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_CHANGED))) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
child->common.fn_flags |= ZEND_ACC_CHANGED;
}
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
proto = parent->common.prototype ?
parent->common.prototype : parent;
if (parent_flags & ZEND_ACC_CTOR) {
/* ctors only have a prototype if is abstract (or comes from an interface) */
/* and if that is the case, we want to check inheritance against it */
if (!(proto->common.fn_flags & ZEND_ACC_ABSTRACT)) {
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
return INHERITANCE_SUCCESS;
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
}
parent = proto;
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (!check_only && child->common.prototype != proto && child_zv) {
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
do {
Don't use separate static variables in inherited methods RFC: https://wiki.php.net/rfc/static_variable_inheritance Closes GH-6719.
2021-02-22 19:28:02 +08:00
if (child->common.scope != ce && child->type == ZEND_USER_FUNCTION) {
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
if (ce->ce_flags & ZEND_ACC_INTERFACE) {
/* Few parent interfaces contain the same method */
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
break;
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
} else {
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
/* op_array wasn't duplicated yet */
zend_function *new_function = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
memcpy(new_function, child, sizeof(zend_op_array));
Z_PTR_P(child_zv) = child = new_function;
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
}
}
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
child->common.prototype = proto;
} while (0);
}
Get rid of ZEND_ACC_CTOR, ZEND_ACC_DTOR and ZEND_ACC_IMPLEMENTED_ABSTRACT
2018-09-05 18:16:10 +08:00
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
/* Prevent derived classes from restricting access that was available in parent classes (except deriving from non-abstract ctors) */
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (!checked && check_visibility
&& (child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (check_only) {
return INHERITANCE_ERROR;
}
Fixed bug #81192 Normally the filename is the current filename, but when traits are involved, it might be a different one.
2021-08-12 20:34:48 +08:00
zend_error_at_noreturn(E_COMPILE_ERROR, func_filename(child), func_lineno(child),
Remove always true/false conditions, remove dead conde and simplify code.
2019-06-26 05:32:22 +08:00
"Access level to %s::%s() must be %s (as in class %s)%s",
ZEND_FN_SCOPE_NAME(child), ZSTR_VAL(child->common.function_name), zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (!checked) {
if (check_only) {
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
return zend_do_perform_implementation_check(child, child_scope, parent, parent_scope);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
perform_delayable_implementation_check(ce, child, child_scope, parent, parent_scope);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
return INHERITANCE_SUCCESS;
}
/* }}} */
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
static zend_never_inline void do_inheritance_check_on_method(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_function *child, zend_class_entry *child_scope,
zend_function *parent, zend_class_entry *parent_scope,
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
zend_class_entry *ce, zval *child_zv, bool check_visibility)
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
{
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
do_inheritance_check_on_method_ex(child, child_scope, parent, parent_scope, ce, child_zv, check_visibility, 0, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
static zend_always_inline void do_inherit_method(zend_string *key, zend_function *parent, zend_class_entry *ce, bool is_interface, bool checked) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Remove leading underscore for _zend_hash_find_known_hash (#7260) Convert zend_hash_find_ex(..., 1) to zend_hash_find_known_hash(...) Convert zend_hash_find_ex(..., 0) to zend_hash_find(...) Also add serializable changes to UPGRADING.INTERNALS summary
2021-07-21 07:07:17 +08:00
zval *child = zend_hash_find_known_hash(&ce->function_table, key);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (child) {
Fixed bug #71248 (Wrong interface is enforced)
2016-01-13 16:41:57 +08:00
zend_function *func = (zend_function*)Z_PTR_P(child);
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (is_interface && UNEXPECTED(func == parent)) {
typo
2018-10-03 19:35:36 +08:00
/* The same method in interface may be inherited few times */
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
return;
Avoid method compatibility check with itself
2018-10-03 17:32:33 +08:00
}
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (checked) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
do_inheritance_check_on_method_ex(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
func, func->common.scope, parent, parent->common.scope, ce, child,
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
/* check_visibility */ 1, 0, checked);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
} else {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
do_inheritance_check_on_method(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
func, func->common.scope, parent, parent->common.scope, ce, child,
/* check_visibility */ 1);
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
}
} else {
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (is_interface || (parent->common.fn_flags & (ZEND_ACC_ABSTRACT))) {
ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
}
Don't use separate static variables in inherited methods RFC: https://wiki.php.net/rfc/static_variable_inheritance Closes GH-6719.
2021-02-22 19:28:02 +08:00
parent = zend_duplicate_function(parent, ce);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
if (!is_interface) {
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
_zend_hash_append_ptr(&ce->function_table, key, parent);
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
} else {
zend_hash_add_new_ptr(&ce->function_table, key, parent);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
/* }}} */
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
inheritance_status property_types_compatible(
const zend_property_info *parent_info, const zend_property_info *child_info) {
Make zend_type a 2-field struct We now store the pointer payload and the type mask separately. This is in preparation for union types, where we will be using both at the same time. To avoid increasing the size of arginfo structures, the pass_by_reference and is_variadic fields are now stored as part of the type_mask (8-bit are reserved for custom use). Different types of pointer payloads are distinguished based on bits in the type_mask.
2019-09-20 23:01:19 +08:00
if (ZEND_TYPE_PURE_MASK(parent_info->type) == ZEND_TYPE_PURE_MASK(child_info->type)
&& ZEND_TYPE_NAME(parent_info->type) == ZEND_TYPE_NAME(child_info->type)) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return INHERITANCE_SUCCESS;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (ZEND_TYPE_IS_SET(parent_info->type) != ZEND_TYPE_IS_SET(child_info->type)) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return INHERITANCE_ERROR;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
/* Perform a covariant type check in both directions to determined invariance. */
inheritance_status status1 = zend_perform_covariant_type_check(
Move INHERITANCE_WARNING handling one layer up There is only a single place where we need to convert ERROR into WARNING, don't thread it through more places than necessary.
2021-06-30 21:45:42 +08:00
child_info->ce, child_info->type, parent_info->ce, parent_info->type);
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
inheritance_status status2 = zend_perform_covariant_type_check(
Move INHERITANCE_WARNING handling one layer up There is only a single place where we need to convert ERROR into WARNING, don't thread it through more places than necessary.
2021-06-30 21:45:42 +08:00
parent_info->ce, parent_info->type, child_info->ce, child_info->type);
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (status1 == INHERITANCE_SUCCESS && status2 == INHERITANCE_SUCCESS) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
return INHERITANCE_SUCCESS;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
if (status1 == INHERITANCE_ERROR || status2 == INHERITANCE_ERROR) {
return INHERITANCE_ERROR;
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
}
Fix incorrect assertion in property type variance check Only one of the status has to be UNRESOLVED, the other could also be SUCCESS. Fixes oss-fuzz #19108 and oss-fuzz #19111.
2019-12-04 18:07:22 +08:00
ZEND_ASSERT(status1 == INHERITANCE_UNRESOLVED || status2 == INHERITANCE_UNRESOLVED);
Implement union types According to RFC: https://wiki.php.net/rfc/union_types_v2 The type representation now makes use of both the pointer payload and the type mask at the same time. Additionall, zend_type_list is introduced as a new kind of pointer payload, which is used to store multiple class types. Each of the class types is a tagged pointer, which may be either a class name or class entry. The latter is only used for typed properties, while arguments/returns will instead use cache slots. A type list can contain a mix of both names and CEs at the same time, as not all classes may be resolvable. One thing this is missing is support for union types in arginfo and stubs, which I want to handle separately. I've also dropped the special object code from the JIT implementation for now -- I plan to add this back in a different form at a later time. For now I did not want to include non-trivial JIT changes together with large functional changes. Another possible piece of follow-up work is to implement "iterable" as an internal alias for "array|Traversable". I believe this will eliminate quite a few special-cases that had to be implemented. Closes GH-4838.
2019-09-25 19:21:13 +08:00
return INHERITANCE_UNRESOLVED;
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
}
static void emit_incompatible_property_error(
const zend_property_info *child, const zend_property_info *parent) {
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
zend_string *type_str = zend_type_to_string_resolved(parent->type, parent->ce);
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
zend_error_noreturn(E_COMPILE_ERROR,
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
"Type of %s::$%s must be %s (as in class %s)",
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
ZSTR_VAL(child->ce->name),
Use unmangled named in property type inheritance error
2019-12-09 15:48:33 +08:00
zend_get_unmangled_property_name(child->name),
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
ZSTR_VAL(type_str),
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
ZSTR_VAL(parent->ce->name));
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
static void do_inherit_property(zend_property_info *parent_info, zend_string *key, zend_class_entry *ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Remove leading underscore for _zend_hash_find_known_hash (#7260) Convert zend_hash_find_ex(..., 1) to zend_hash_find_known_hash(...) Convert zend_hash_find_ex(..., 0) to zend_hash_find(...) Also add serializable changes to UPGRADING.INTERNALS summary
2021-07-21 07:07:17 +08:00
zval *child = zend_hash_find_known_hash(&ce->properties_info, key);
Improved ineritance code
2015-03-05 04:06:07 +08:00
zend_property_info *child_info;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Improved ineritance code
2015-03-05 04:06:07 +08:00
if (UNEXPECTED(child)) {
child_info = Z_PTR_P(child);
Better ZEND_ACC_CHANGED handling
2018-09-12 16:43:15 +08:00
if (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_CHANGED)) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
child_info->flags |= ZEND_ACC_CHANGED;
Better ZEND_ACC_CHANGED handling
2018-09-12 16:43:15 +08:00
}
if (!(parent_info->flags & ZEND_ACC_PRIVATE)) {
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC))) {
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
Prefer using declaring class rather than direct parent in error Point to the class that actually declares the property, which is not necessarily the same as the direct parent class.
2020-01-22 00:19:07 +08:00
(parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(parent_info->ce->name), ZSTR_VAL(key),
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
(child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ZSTR_VAL(ce->name), ZSTR_VAL(key));
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
}
Implement readonly properties Add support for readonly properties, for which only a single initializing assignment from the declaring scope is allowed. RFC: https://wiki.php.net/rfc/readonly_properties_v2 Closes GH-7089.
2021-06-02 16:02:56 +08:00
if (UNEXPECTED((child_info->flags & ZEND_ACC_READONLY) != (parent_info->flags & ZEND_ACC_READONLY))) {
zend_error_noreturn(E_COMPILE_ERROR,
"Cannot redeclare %s property %s::$%s as %s %s::$%s",
parent_info->flags & ZEND_ACC_READONLY ? "readonly" : "non-readonly",
ZSTR_VAL(parent_info->ce->name), ZSTR_VAL(key),
child_info->flags & ZEND_ACC_READONLY ? "readonly" : "non-readonly",
ZSTR_VAL(ce->name), ZSTR_VAL(key));
}
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK))) {
Prefer using declaring class rather than direct parent in error Point to the class that actually declares the property, which is not necessarily the same as the direct parent class.
2020-01-22 00:19:07 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ZSTR_VAL(ce->name), ZSTR_VAL(key), zend_visibility_string(parent_info->flags), ZSTR_VAL(parent_info->ce->name), (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
} else if ((child_info->flags & ZEND_ACC_STATIC) == 0) {
int parent_num = OBJ_PROP_TO_NUM(parent_info->offset);
int child_num = OBJ_PROP_TO_NUM(child_info->offset);
Fixed typo
2016-05-06 14:48:58 +08:00
/* Don't keep default properties in GC (they may be freed by opcache) */
Merge branch 'PHP-5.6' into PHP-7.0 * PHP-5.6: Prevent usage in GC after free.
2016-04-19 06:37:24 +08:00
zval_ptr_dtor_nogc(&(ce->default_properties_table[parent_num]));
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
ce->default_properties_table[parent_num] = ce->default_properties_table[child_num];
ZVAL_UNDEF(&ce->default_properties_table[child_num]);
child_info->offset = parent_info->offset;
}
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (UNEXPECTED(ZEND_TYPE_IS_SET(parent_info->type))) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
inheritance_status status = property_types_compatible(parent_info, child_info);
if (status == INHERITANCE_ERROR) {
emit_incompatible_property_error(child_info, parent_info);
}
if (status == INHERITANCE_UNRESOLVED) {
add_property_compatibility_obligation(ce, child_info, parent_info);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
} else if (UNEXPECTED(ZEND_TYPE_IS_SET(child_info->type) && !ZEND_TYPE_IS_SET(parent_info->type))) {
zend_error_noreturn(E_COMPILE_ERROR,
"Type of %s::$%s must not be defined (as in class %s)",
ZSTR_VAL(ce->name),
ZSTR_VAL(key),
Prefer using declaring class rather than direct parent in error Point to the class that actually declares the property, which is not necessarily the same as the direct parent class.
2020-01-22 00:19:07 +08:00
ZSTR_VAL(parent_info->ce->name));
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
}
} else {
Don't duplicate internal prop info (#6929) Userland property infos are no longer duplicated since PHP 7.4, when we stopped setting SHADOW flags on inherited private properties. Stop duplicating internal property infos as well. This requires switching class destruction to work in reverse order, as child classes may be reusing structures from parent classes, and as such should be destroyed first.
2021-04-30 02:31:24 +08:00
_zend_hash_append_ptr(&ce->properties_info, key, parent_info);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce) == FAILURE) {
Improve error message class type Refer to interfaces/enums instead of classes in more places. Closes GH-7792 Closes GH-8187
2022-03-10 21:41:07 +08:00
zend_error_noreturn(E_CORE_ERROR, "%s %s could not implement interface %s", zend_get_object_type_uc(ce), ZSTR_VAL(ce->name), ZSTR_VAL(iface->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Only allow "nearly linked" classes for parent/interface The requirements for parent/interface are difference than for the variance checks in type declarations. The latter can work on fully unlinked classes, but the former need inheritance to be essentially finished, only variance checks may still be outstanding. Adding a new flag for this because we have lots of space, but we could also represent these "inheritance states" more compactly in the future.
2019-09-11 22:27:28 +08:00
/* This should be prevented by the class lookup logic. */
ZEND_ASSERT(ce != iface);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
static void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
/* expects interface to be contained in ce's interface list already */
uint32_t i, ce_num, if_num = iface->num_interfaces;
zend_class_entry *entry;
ce_num = ce->num_interfaces;
if (ce->type == ZEND_INTERNAL_CLASS) {
ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
} else {
ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (ce_num + if_num));
}
/* Inherit the interfaces, only if they're not already inherited by the class */
while (if_num--) {
entry = iface->interfaces[if_num];
for (i = 0; i < ce_num; i++) {
if (ce->interfaces[i] == entry) {
break;
}
}
if (i == ce_num) {
ce->interfaces[ce->num_interfaces++] = entry;
}
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
ce->ce_flags |= ZEND_ACC_RESOLVED_INTERFACES;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* and now call the implementing handlers */
while (ce_num < ce->num_interfaces) {
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
do_implement_interface(ce, ce->interfaces[ce_num++]);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
static void do_inherit_class_constant(zend_string *name, zend_class_constant *parent_const, zend_class_entry *ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Remove leading underscore for _zend_hash_find_known_hash (#7260) Convert zend_hash_find_ex(..., 1) to zend_hash_find_known_hash(...) Convert zend_hash_find_ex(..., 0) to zend_hash_find(...) Also add serializable changes to UPGRADING.INTERNALS summary
2021-07-21 07:07:17 +08:00
zval *zv = zend_hash_find_known_hash(&ce->constants_table, name);
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 19:01:19 +08:00
zend_class_constant *c;
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
Introduced zend_hash_find_ex() that may avoid unnecessary hash value check.
2017-11-24 19:01:19 +08:00
if (zv != NULL) {
c = (zend_class_constant*)Z_PTR_P(zv);
Add ZEND_CLASS_CONST_FLAGS() macro And drop Z_ACCESS_FLAGS(). We no longer store *only* access flags in these.
2021-04-28 20:51:54 +08:00
if (UNEXPECTED((ZEND_CLASS_CONST_FLAGS(c) & ZEND_ACC_PPP_MASK) > (ZEND_CLASS_CONST_FLAGS(parent_const) & ZEND_ACC_PPP_MASK))) {
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s must be %s (as in class %s)%s",
Add ZEND_CLASS_CONST_FLAGS() macro And drop Z_ACCESS_FLAGS(). We no longer store *only* access flags in these.
2021-04-28 20:51:54 +08:00
ZSTR_VAL(ce->name), ZSTR_VAL(name), zend_visibility_string(ZEND_CLASS_CONST_FLAGS(parent_const)), ZSTR_VAL(parent_const->ce->name), (ZEND_CLASS_CONST_FLAGS(parent_const) & ZEND_ACC_PUBLIC) ? "" : " or weaker");
Improved ineritance code
2015-03-05 04:06:07 +08:00
}
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
if (UNEXPECTED((ZEND_CLASS_CONST_FLAGS(parent_const) & ZEND_ACC_FINAL))) {
zend_error_noreturn(
E_COMPILE_ERROR, "%s::%s cannot override final constant %s::%s",
ZSTR_VAL(ce->name), ZSTR_VAL(name), ZSTR_VAL(parent_const->ce->name), ZSTR_VAL(name)
);
}
Add ZEND_CLASS_CONST_FLAGS() macro And drop Z_ACCESS_FLAGS(). We no longer store *only* access flags in these.
2021-04-28 20:51:54 +08:00
} else if (!(ZEND_CLASS_CONST_FLAGS(parent_const) & ZEND_ACC_PRIVATE)) {
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
if (Z_TYPE(parent_const->value) == IS_CONSTANT_AST) {
Improved ineritance code
2015-03-05 04:06:07 +08:00
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
ce->ce_flags |= ZEND_ACC_HAS_AST_CONSTANTS;
if (ce->parent->ce_flags & ZEND_ACC_IMMUTABLE) {
c = zend_arena_alloc(&CG(arena), sizeof(zend_class_constant));
memcpy(c, parent_const, sizeof(zend_class_constant));
parent_const = c;
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Fixed use-after free introduced in fcc08ce19f39f7ab1381ecc8a010037d41819329
2017-10-31 06:20:38 +08:00
if (ce->type & ZEND_INTERNAL_CLASS) {
c = pemalloc(sizeof(zend_class_constant), 1);
memcpy(c, parent_const, sizeof(zend_class_constant));
parent_const = c;
}
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
_zend_hash_append_ptr(&ce->constants_table, name, parent_const);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
void zend_build_properties_info_table(zend_class_entry *ce)
{
zend_property_info **table, *prop;
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
size_t size;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (ce->default_properties_count == 0) {
return;
}
ZEND_ASSERT(ce->properties_info_table == NULL);
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
size = sizeof(zend_property_info *) * ce->default_properties_count;
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (ce->type == ZEND_USER_CLASS) {
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
ce->properties_info_table = table = zend_arena_alloc(&CG(arena), size);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
} else {
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
ce->properties_info_table = table = pemalloc(size, 1);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
}
Avoid uninitialized entries in properties_info_table Also don't place it into xlat, there's only ever one user.
2019-02-15 20:42:37 +08:00
/* Dead slots may be left behind during inheritance. Make sure these are NULLed out. */
memset(table, 0, size);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (ce->parent && ce->parent->default_properties_count != 0) {
zend_property_info **parent_table = ce->parent->properties_info_table;
memcpy(
table, parent_table,
sizeof(zend_property_info *) * ce->parent->default_properties_count
);
/* Child did not add any new properties, we are done */
if (ce->default_properties_count == ce->parent->default_properties_count) {
return;
}
}
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, prop) {
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
if (prop->ce == ce && (prop->flags & ZEND_ACC_STATIC) == 0) {
table[OBJ_PROP_TO_NUM(prop->offset)] = prop;
}
} ZEND_HASH_FOREACH_END();
}
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
ZEND_API void zend_do_inheritance_ex(zend_class_entry *ce, zend_class_entry *parent_ce, bool checked) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
zend_property_info *property_info;
zend_function *func;
zend_string *key;
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED(ce->ce_flags & ZEND_ACC_INTERFACE)) {
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
/* Interface can only inherit other interfaces */
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED(!(parent_ce->ce_flags & ZEND_ACC_INTERFACE))) {
Improve class inheritance error messages (#7307)
2021-07-27 15:42:37 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Interface %s cannot extend class %s", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name));
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
}
Improved ineritance code
2015-03-05 04:06:07 +08:00
} else if (UNEXPECTED(parent_ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_FINAL))) {
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
/* Class must not extend a final class */
if (parent_ce->ce_flags & ZEND_ACC_FINAL) {
Improve class inheritance error messages (#7307)
2021-07-27 15:42:37 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend final class %s", ZSTR_VAL(ce->name), ZSTR_VAL(parent_ce->name));
}
/* Class declaration must not extend traits or interfaces */
if ((parent_ce->ce_flags & ZEND_ACC_INTERFACE) || (parent_ce->ce_flags & ZEND_ACC_TRAIT)) {
zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend %s %s",
ZSTR_VAL(ce->name), parent_ce->ce_flags & ZEND_ACC_INTERFACE ? "interface" : "trait", ZSTR_VAL(parent_ce->name)
);
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Add support for readonly classes (#7305) RFC: https://wiki.php.net/rfc/readonly_classes
2022-05-17 02:40:23 +08:00
if (UNEXPECTED((ce->ce_flags & ZEND_ACC_READONLY_CLASS) != (parent_ce->ce_flags & ZEND_ACC_READONLY_CLASS))) {
zend_error_noreturn(E_COMPILE_ERROR, "%s class %s cannot extend %s class %s",
ce->ce_flags & ZEND_ACC_READONLY_CLASS ? "Readonly" : "Non-readonly", ZSTR_VAL(ce->name),
parent_ce->ce_flags & ZEND_ACC_READONLY_CLASS ? "readonly" : "non-readonly", ZSTR_VAL(parent_ce->name)
);
}
Replace ZEND_ACC_ANON_BOUND, ZEND_ACC_UNRESOLVED_PARENT and ZEND_ACC_UNRESOLVED_INTERFACES with single ZEND_ACC_LINKED.
2018-09-18 16:41:40 +08:00
if (ce->parent_name) {
Keep information about unresolved parent class in zend_class_entry->parent_name
2018-08-24 05:20:57 +08:00
zend_string_release_ex(ce->parent_name, 0);
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->parent = parent_ce;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
ce->ce_flags |= ZEND_ACC_RESOLVED_PARENT;
Check interface/trait extension for internal classes Removed possibility to have extensions to declare classes extending interfaces or traits. It was checked in user classes, not extensions or internal.
2014-12-06 12:42:52 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* Inherit properties */
if (parent_ce->default_properties_count) {
Improved property inheritance code
2015-04-22 17:53:54 +08:00
zval *src, *dst, *end;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (ce->default_properties_count) {
Improved property inheritance code
2015-04-22 17:53:54 +08:00
zval *table = pemalloc(sizeof(zval) * (ce->default_properties_count + parent_ce->default_properties_count), ce->type == ZEND_INTERNAL_CLASS);
src = ce->default_properties_table + ce->default_properties_count;
end = table + parent_ce->default_properties_count;
dst = end + ce->default_properties_count;
ce->default_properties_table = table;
do {
dst--;
src--;
Fix bug #78226: Don't call __set() on uninitialized typed properties Assigning to an uninitialized typed property will no longer trigger a call to __set(). However, calls to __set() are still triggered if the property is explicitly unset(). This gives us both the behavior people generally expect, and still allows ORMs to do lazy initialization by unsetting properties. For PHP 8, we should fine a way to forbid unsetting of declared properties entirely, and provide a different way to achieve lazy initialization.
2019-10-24 22:36:25 +08:00
ZVAL_COPY_VALUE_PROP(dst, src);
Improved property inheritance code
2015-04-22 17:53:54 +08:00
} while (dst != end);
pefree(src, ce->type == ZEND_INTERNAL_CLASS);
end = ce->default_properties_table;
} else {
end = pemalloc(sizeof(zval) * parent_ce->default_properties_count, ce->type == ZEND_INTERNAL_CLASS);
dst = end + parent_ce->default_properties_count;
ce->default_properties_table = end;
}
src = parent_ce->default_properties_table + parent_ce->default_properties_count;
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
if (UNEXPECTED(parent_ce->type != ce->type)) {
/* User class extends internal */
do {
dst--;
src--;
Fix bug #78226: Don't call __set() on uninitialized typed properties Assigning to an uninitialized typed property will no longer trigger a call to __set(). However, calls to __set() are still triggered if the property is explicitly unset(). This gives us both the behavior people generally expect, and still allows ORMs to do lazy initialization by unsetting properties. For PHP 8, we should fine a way to forbid unsetting of declared properties entirely, and provide a different way to achieve lazy initialization.
2019-10-24 22:36:25 +08:00
ZVAL_COPY_OR_DUP_PROP(dst, src);
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
if (Z_OPT_TYPE_P(dst) == IS_CONSTANT_AST) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
ce->ce_flags |= ZEND_ACC_HAS_AST_PROPERTIES;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
continue;
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
} while (dst != end);
} else {
do {
dst--;
src--;
Fix bug #78226: Don't call __set() on uninitialized typed properties Assigning to an uninitialized typed property will no longer trigger a call to __set(). However, calls to __set() are still triggered if the property is explicitly unset(). This gives us both the behavior people generally expect, and still allows ORMs to do lazy initialization by unsetting properties. For PHP 8, we should fine a way to forbid unsetting of declared properties entirely, and provide a different way to achieve lazy initialization.
2019-10-24 22:36:25 +08:00
ZVAL_COPY_PROP(dst, src);
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
if (Z_OPT_TYPE_P(dst) == IS_CONSTANT_AST) {
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
ce->ce_flags |= ZEND_ACC_HAS_AST_PROPERTIES;
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
}
continue;
} while (dst != end);
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->default_properties_count += parent_ce->default_properties_count;
}
Improved property inheritance code
2015-04-22 17:53:54 +08:00
if (parent_ce->default_static_members_count) {
zval *src, *dst, *end;
if (ce->default_static_members_count) {
zval *table = pemalloc(sizeof(zval) * (ce->default_static_members_count + parent_ce->default_static_members_count), ce->type == ZEND_INTERNAL_CLASS);
src = ce->default_static_members_table + ce->default_static_members_count;
end = table + parent_ce->default_static_members_count;
dst = end + ce->default_static_members_count;
ce->default_static_members_table = table;
do {
dst--;
src--;
ZVAL_COPY_VALUE(dst, src);
} while (dst != end);
pefree(src, ce->type == ZEND_INTERNAL_CLASS);
end = ce->default_static_members_table;
} else {
end = pemalloc(sizeof(zval) * parent_ce->default_static_members_count, ce->type == ZEND_INTERNAL_CLASS);
dst = end + parent_ce->default_static_members_count;
ce->default_static_members_table = end;
}
Always use separate static_members_table When running without opcache, static_members_table is shared with default_static_members_table. This is visible in reflection output, because ReflectionProperty::getDefaultValue() will return the current value, rather than the default value. Address this by never sharing the table, which matches the behavior we already see under opcache. Fixes bug #80821. Closes GH-7299.
2021-07-22 17:41:24 +08:00
src = parent_ce->default_static_members_table + parent_ce->default_static_members_count;
do {
dst--;
src--;
if (Z_TYPE_P(src) == IS_INDIRECT) {
ZVAL_INDIRECT(dst, Z_INDIRECT_P(src));
} else {
ZVAL_INDIRECT(dst, src);
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
}
Always use separate static_members_table When running without opcache, static_members_table is shared with default_static_members_table. This is visible in reflection output, because ReflectionProperty::getDefaultValue() will return the current value, rather than the default value. Address this by never sharing the table, which matches the behavior we already see under opcache. Fixes bug #80821. Closes GH-7299.
2021-07-22 17:41:24 +08:00
if (Z_TYPE_P(Z_INDIRECT_P(dst)) == IS_CONSTANT_AST) {
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
ce->ce_flags |= ZEND_ACC_HAS_AST_STATICS;
Don't initialize static_member_tables during start-up, when inherit internal classes.
2018-10-19 18:21:31 +08:00
}
Always use separate static_members_table When running without opcache, static_members_table is shared with default_static_members_table. This is visible in reflection output, because ReflectionProperty::getDefaultValue() will return the current value, rather than the default value. Address this by never sharing the table, which matches the behavior we already see under opcache. Fixes bug #80821. Closes GH-7299.
2021-07-22 17:41:24 +08:00
} while (dst != end);
Improved property inheritance code
2015-04-22 17:53:54 +08:00
ce->default_static_members_count += parent_ce->default_static_members_count;
Immutable clases and op_arrays. Squashed commit of the following: commit cd0c36c3f943849e5b97a8dbe2dd029fbeab3df9 Merge: 4740dabb84 ad6738e886 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:43:38 2018 +0300 Merge branch 'master' into immutable * master: Remove the "auto" encoding Fixed bug #77025 Add vtbls for EUC-TW encoding commit 4740dabb843c6d4f7f866b4a2456073c9eaf4c77 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:12:28 2018 +0300 Reverted back ce->iterator_funcs_ptr. Initialize ce->iterator_funcs_ptr fields in immutable classes. commit ad7a78b253be970db70c2251e66f9297d8e7f829 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:46:30 2018 +0300 Added comment commit 0276ea51875bab37be01a4dc5e5a047c5698c571 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:42:43 2018 +0300 Added type cast commit c63fc5d5f19c58498108d1698055b2b442227eb3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:36:51 2018 +0300 Moved static class members initialization into the proper place. commit b945548e9306b1826c881918858b5e5aa3eb3002 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:21:03 2018 +0300 Removed redundand assertion commit d5a41088401814c829847db212488f8aae39bcd2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:19:13 2018 +0300 Removed duplicate code commit 8dadca8864e66de70a24bdf1181bcf7dd8fb27d7 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:05:43 2018 +0300 Hide offset encoding magic in ZEND_MAP_PTR_IS_OFFSET(), ZEND_MAP_PTR_OFFSET2PTR() and ZEND_MAP_PTR_PTR2OFFSET() macros. commit 9ef07c88bd76801e2d4fbfeab3ebfd6e6a67ac5f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:48:29 2018 +0300 typo commit a06f0f3d3aba53e766046221ee44fb9720389ecc Merge: 94099586ec 3412345ffe Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:47:07 2018 +0300 Merge branch 'master' into immutable * master: Remove unused variable makefile_am_files Classify object handlers are required/optional Add support for getting SKIP_TAGSTART and SKIP_WHITE options Remove some obsolete config_vars.mk occurrences Remove bsd_converted from .gitignore Remove configuration parser and scanners ignores Remove obsolete buildconf.stamp from .gitignore [ci skip] Add magicdata.patch exception to .gitignore Remove outdated ext/spl/examples items from .gitignore Remove unused test.inc in ext/iconv/tests commit 94099586ec599117581ca01c15b1f6c5f749e23a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Oct 15 23:34:01 2018 +0300 Immutable clases and op_arrays
2018-10-17 20:52:50 +08:00
if (!ZEND_MAP_PTR(ce->static_members_table)) {
Always use separate static_members_table When running without opcache, static_members_table is shared with default_static_members_table. This is visible in reflection output, because ReflectionProperty::getDefaultValue() will return the current value, rather than the default value. Address this by never sharing the table, which matches the behavior we already see under opcache. Fixes bug #80821. Closes GH-7299.
2021-07-22 17:41:24 +08:00
if (ce->type == ZEND_INTERNAL_CLASS &&
ce->info.internal.module->type == MODULE_PERSISTENT) {
Immutable clases and op_arrays. Squashed commit of the following: commit cd0c36c3f943849e5b97a8dbe2dd029fbeab3df9 Merge: 4740dabb84 ad6738e886 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:43:38 2018 +0300 Merge branch 'master' into immutable * master: Remove the "auto" encoding Fixed bug #77025 Add vtbls for EUC-TW encoding commit 4740dabb843c6d4f7f866b4a2456073c9eaf4c77 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:12:28 2018 +0300 Reverted back ce->iterator_funcs_ptr. Initialize ce->iterator_funcs_ptr fields in immutable classes. commit ad7a78b253be970db70c2251e66f9297d8e7f829 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:46:30 2018 +0300 Added comment commit 0276ea51875bab37be01a4dc5e5a047c5698c571 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:42:43 2018 +0300 Added type cast commit c63fc5d5f19c58498108d1698055b2b442227eb3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:36:51 2018 +0300 Moved static class members initialization into the proper place. commit b945548e9306b1826c881918858b5e5aa3eb3002 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:21:03 2018 +0300 Removed redundand assertion commit d5a41088401814c829847db212488f8aae39bcd2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:19:13 2018 +0300 Removed duplicate code commit 8dadca8864e66de70a24bdf1181bcf7dd8fb27d7 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:05:43 2018 +0300 Hide offset encoding magic in ZEND_MAP_PTR_IS_OFFSET(), ZEND_MAP_PTR_OFFSET2PTR() and ZEND_MAP_PTR_PTR2OFFSET() macros. commit 9ef07c88bd76801e2d4fbfeab3ebfd6e6a67ac5f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:48:29 2018 +0300 typo commit a06f0f3d3aba53e766046221ee44fb9720389ecc Merge: 94099586ec 3412345ffe Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:47:07 2018 +0300 Merge branch 'master' into immutable * master: Remove unused variable makefile_am_files Classify object handlers are required/optional Add support for getting SKIP_TAGSTART and SKIP_WHITE options Remove some obsolete config_vars.mk occurrences Remove bsd_converted from .gitignore Remove configuration parser and scanners ignores Remove obsolete buildconf.stamp from .gitignore [ci skip] Add magicdata.patch exception to .gitignore Remove outdated ext/spl/examples items from .gitignore Remove unused test.inc in ext/iconv/tests commit 94099586ec599117581ca01c15b1f6c5f749e23a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Oct 15 23:34:01 2018 +0300 Immutable clases and op_arrays
2018-10-17 20:52:50 +08:00
ZEND_MAP_PTR_NEW(ce->static_members_table);
Allocate only necessary space for static properties of internal classes in ZTS mode.
2018-10-02 00:05:31 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_PTR(&ce->properties_info, property_info) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (property_info->ce == ce) {
if (property_info->flags & ZEND_ACC_STATIC) {
property_info->offset += parent_ce->default_static_members_count;
} else {
Improved object property access.
2014-11-06 19:50:03 +08:00
property_info->offset += parent_ce->default_properties_count * sizeof(zval);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
} ZEND_HASH_FOREACH_END();
Improved ineritance code
2015-03-05 04:06:07 +08:00
if (zend_hash_num_elements(&parent_ce->properties_info)) {
zend_hash_extend(&ce->properties_info,
zend_hash_num_elements(&ce->properties_info) +
zend_hash_num_elements(&parent_ce->properties_info), 0);
Improved code for class property inheritance
2015-03-04 22:41:01 +08:00
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&parent_ce->properties_info, key, property_info) {
Improved ineritance code
2015-03-05 04:06:07 +08:00
do_inherit_property(property_info, key, ce);
} ZEND_HASH_FOREACH_END();
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Improved ineritance code
2015-03-05 04:06:07 +08:00
if (zend_hash_num_elements(&parent_ce->constants_table)) {
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
zend_class_constant *c;
Improved ineritance code
2015-03-05 04:06:07 +08:00
zend_hash_extend(&ce->constants_table,
zend_hash_num_elements(&ce->constants_table) +
zend_hash_num_elements(&parent_ce->constants_table), 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&parent_ce->constants_table, key, c) {
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
do_inherit_class_constant(key, c, ce);
Improved ineritance code
2015-03-05 04:06:07 +08:00
} ZEND_HASH_FOREACH_END();
}
if (zend_hash_num_elements(&parent_ce->function_table)) {
zend_hash_extend(&ce->function_table,
zend_hash_num_elements(&ce->function_table) +
zend_hash_num_elements(&parent_ce->function_table), 0);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (checked) {
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, func) {
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_inherit_method(key, func, ce, 0, 1);
} ZEND_HASH_FOREACH_END();
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
} else {
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, func) {
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_inherit_method(key, func, ce, 0, 0);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
} ZEND_HASH_FOREACH_END();
}
Improved ineritance code
2015-03-05 04:06:07 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
do_inherit_parent_constructor(ce);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Cleanup class linking
2018-08-27 21:40:25 +08:00
if (ce->type == ZEND_INTERNAL_CLASS) {
Implement interfaces after all methods available The place where interface implementation handlers is called is currently ill-defined: If the class implements interfaces itself, the handlers for both the parent interfaces and the new interfaces will be called after all methods are registered (post trait use). If the class does not implement interfaces, then the parent interface handlers are called early during inheritance (before methods are inherited). This commit moves the calls to always occur after all methods are available. For userland classes this will be post trait import, at the time where interfaces get implemented (whether the class itself defines additional interfaces or not). For internal classes it will be at the end of inheritance, as internal class declarations do not have proper finalization. This allows us to simplify the logic for implementing the magic Iterator / IteratorAggregate interfaces. In particularly we can now also automatically detect whether an extension of IteratorAggregate can safely reuse a custom get_iterator handler, or whether it needs to switch to the userland mechanism. The Iterator case continues to rely on ZEND_ACC_REUSE_GET_ITERATOR for this purpose, as a wholesale replacement is not possible there.
2020-03-04 17:10:36 +08:00
if (parent_ce->num_interfaces) {
zend_do_inherit_interfaces(ce, parent_ce);
}
Cleanup class linking
2018-08-27 21:40:25 +08:00
if (ce->ce_flags & ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
ce->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Deprecate implicit dynamic properties Writing to a proprety that hasn't been declared is deprecated, unless the class uses the #[AllowDynamicProperties] attribute or defines __get()/__set(). RFC: https://wiki.php.net/rfc/deprecate_dynamic_properties
2021-10-11 21:49:27 +08:00
ce->ce_flags |= parent_ce->ce_flags & (ZEND_HAS_STATIC_IN_METHODS | ZEND_ACC_HAS_TYPE_HINTS | ZEND_ACC_USE_GUARDS | ZEND_ACC_NOT_SERIALIZABLE | ZEND_ACC_ALLOW_DYNAMIC_PROPERTIES);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Implement constants in traits (#8888) RFC: https://wiki.php.net/rfc/constants_in_traits
2022-08-05 03:08:40 +08:00
static zend_always_inline bool check_trait_property_or_constant_value_compatibility(zend_class_entry *ce, zval *op1, zval *op2) /* {{{ */
{
bool is_compatible;
zval op1_tmp, op2_tmp;
/* if any of the values is a constant, we try to resolve it */
if (UNEXPECTED(Z_TYPE_P(op1) == IS_CONSTANT_AST)) {
ZVAL_COPY_OR_DUP(&op1_tmp, op1);
zval_update_constant_ex(&op1_tmp, ce);
op1 = &op1_tmp;
}
if (UNEXPECTED(Z_TYPE_P(op2) == IS_CONSTANT_AST)) {
ZVAL_COPY_OR_DUP(&op2_tmp, op2);
zval_update_constant_ex(&op2_tmp, ce);
op2 = &op2_tmp;
}
is_compatible = fast_is_identical_function(op1, op2);
if (op1 == &op1_tmp) {
zval_ptr_dtor_nogc(&op1_tmp);
}
if (op2 == &op2_tmp) {
zval_ptr_dtor_nogc(&op2_tmp);
}
return is_compatible;
}
/* }}} */
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
static bool do_inherit_constant_check(
zend_class_entry *ce, zend_class_constant *parent_constant, zend_string *name
) {
Remove leading underscore for _zend_hash_find_known_hash (#7260) Convert zend_hash_find_ex(..., 1) to zend_hash_find_known_hash(...) Convert zend_hash_find_ex(..., 0) to zend_hash_find(...) Also add serializable changes to UPGRADING.INTERNALS summary
2021-07-21 07:07:17 +08:00
zval *zv = zend_hash_find_known_hash(&ce->constants_table, name);
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
if (zv == NULL) {
return true;
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
zend_class_constant *old_constant = Z_PTR_P(zv);
Fix GH-7757: Multi-inherited final constant causes fatal error "Diamond" inheritance of final constants is supposed to be supported. Closes GH-7767.
2021-12-13 02:53:02 +08:00
if (parent_constant->ce != old_constant->ce && (ZEND_CLASS_CONST_FLAGS(parent_constant) & ZEND_ACC_FINAL)) {
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "%s::%s cannot override final constant %s::%s",
ZSTR_VAL(old_constant->ce->name), ZSTR_VAL(name),
ZSTR_VAL(parent_constant->ce->name), ZSTR_VAL(name)
);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
if (old_constant->ce != parent_constant->ce && old_constant->ce != ce) {
zend_error_noreturn(E_COMPILE_ERROR,
Improve error message class type Refer to interfaces/enums instead of classes in more places. Closes GH-7792 Closes GH-8187
2022-03-10 21:41:07 +08:00
"%s %s inherits both %s::%s and %s::%s, which is ambiguous",
zend_get_object_type_uc(ce),
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
ZSTR_VAL(ce->name),
ZSTR_VAL(old_constant->ce->name), ZSTR_VAL(name),
ZSTR_VAL(parent_constant->ce->name), ZSTR_VAL(name));
}
return false;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
static void do_inherit_iface_constant(zend_string *name, zend_class_constant *c, zend_class_entry *ce, zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
if (do_inherit_constant_check(ce, c, name)) {
Fixed bug #71413 (Crash with constants on internal interfaces)
2016-01-21 13:30:41 +08:00
zend_class_constant *ct;
Always use IS_CONSTANT_AST (IS_CONSTANT is removed).
2017-10-10 15:11:05 +08:00
if (Z_TYPE(c->value) == IS_CONSTANT_AST) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
ce->ce_flags |= ZEND_ACC_HAS_AST_CONSTANTS;
if (iface->ce_flags & ZEND_ACC_IMMUTABLE) {
ct = zend_arena_alloc(&CG(arena), sizeof(zend_class_constant));
memcpy(ct, c, sizeof(zend_class_constant));
c = ct;
Fix memory leak This fixes oss-fuzz #47088
2022-05-11 16:43:01 +08:00
Z_CONSTANT_FLAGS(c->value) |= CONST_OWNED;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Fixed use-after free introduced in fcc08ce19f39f7ab1381ecc8a010037d41819329
2017-10-31 06:20:38 +08:00
if (ce->type & ZEND_INTERNAL_CLASS) {
ct = pemalloc(sizeof(zend_class_constant), 1);
memcpy(ct, c, sizeof(zend_class_constant));
c = ct;
}
Prevent reference-counting on persistent zvals (internal constants, default properties and constants of internal classes). New macro ZVAL_COPY_OR_DUP() is used perform duplication, if necessary. This should eliminate related race-coditions in ZTS build and prevent reference-counting bugs after unclean shutdown.
2017-10-31 04:13:10 +08:00
zend_hash_update_ptr(&ce->constants_table, name, c);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
static void do_interface_implementation(zend_class_entry *ce, zend_class_entry *iface) /* {{{ */
{
zend_function *func;
zend_string *key;
zend_class_constant *c;
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&iface->constants_table, key, c) {
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_inherit_iface_constant(key, c, ce, iface);
} ZEND_HASH_FOREACH_END();
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&iface->function_table, key, func) {
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_inherit_method(key, func, ce, 1, 0);
} ZEND_HASH_FOREACH_END();
do_implement_interface(ce, iface);
if (iface->num_interfaces) {
zend_do_inherit_interfaces(ce, iface);
}
}
/* }}} */
first shot remove TSRMLS_* things
2014-12-14 06:06:14 +08:00
ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry *iface) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
uint32_t i, ignore = 0;
uint32_t current_iface_num = ce->num_interfaces;
uint32_t parent_iface_num = ce->parent ? ce->parent->num_interfaces : 0;
zend_string *key;
Implemented the RFC `Support Class Constant Visibility`. Squashed commit of the following: commit f11ca0e7a57793fa0e3e7f6d451720e6c42bb0b9 Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:38:42 2015 +0300 Fixed test expectation commit 211f873f542504d0a0f72b6b5cb23908a1c99a2d Author: Dmitry Stogov <dmitry@zend.com> Date: Tue Dec 8 12:28:38 2015 +0300 Embed zend_class_constant.flags into zend_class_constants.value.u2.access_flags commit 51deab84b2cdbf9cdb1a838cf33b2ee45c61748b Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Dec 7 11:18:55 2015 +0300 Fixed issues found by Nikita commit 544dbd5b47e40d38a8ccb96bc5583e9cb7fdd723 Author: Dmitry Stogov <dmitry@zend.com> Date: Sat Dec 5 02:41:05 2015 +0300 Refactored immplementation of https://wiki.php.net/rfc/class_const_visibility @reeze created an RFC here and I emailed internals here and didn't get any responses positive/negative.
2015-12-08 17:40:42 +08:00
zend_class_constant *c;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Replace ZEND_ACC_ANON_BOUND, ZEND_ACC_UNRESOLVED_PARENT and ZEND_ACC_UNRESOLVED_INTERFACES with single ZEND_ACC_LINKED.
2018-09-18 16:41:40 +08:00
ZEND_ASSERT(ce->ce_flags & ZEND_ACC_LINKED);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
for (i = 0; i < ce->num_interfaces; i++) {
if (ce->interfaces[i] == NULL) {
memmove(ce->interfaces + i, ce->interfaces + i + 1, sizeof(zend_class_entry*) * (--ce->num_interfaces - i));
i--;
} else if (ce->interfaces[i] == iface) {
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (EXPECTED(i < parent_iface_num)) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ignore = 1;
} else {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
}
if (ignore) {
/* Check for attempt to redeclare interface constants */
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&iface->constants_table, key, c) {
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
do_inherit_constant_check(ce, c, key);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} ZEND_HASH_FOREACH_END();
} else {
if (ce->num_interfaces >= current_iface_num) {
if (ce->type == ZEND_INTERNAL_CLASS) {
ce->interfaces = (zend_class_entry **) realloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
} else {
ce->interfaces = (zend_class_entry **) erealloc(ce->interfaces, sizeof(zend_class_entry *) * (++current_iface_num));
}
}
ce->interfaces[ce->num_interfaces++] = iface;
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_interface_implementation(ce, iface);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
}
}
/* }}} */
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
static void zend_do_implement_interfaces(zend_class_entry *ce, zend_class_entry **interfaces) /* {{{ */
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
{
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
zend_class_entry *iface;
uint32_t num_parent_interfaces = ce->parent ? ce->parent->num_interfaces : 0;
uint32_t num_interfaces = num_parent_interfaces;
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
zend_string *key;
zend_class_constant *c;
uint32_t i, j;
for (i = 0; i < ce->num_interfaces; i++) {
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
iface = interfaces[num_parent_interfaces + i];
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
if (!(iface->ce_flags & ZEND_ACC_LINKED)) {
add_dependency_obligation(ce, iface);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
}
if (UNEXPECTED(!(iface->ce_flags & ZEND_ACC_INTERFACE))) {
efree(interfaces);
zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ZSTR_VAL(ce->name), ZSTR_VAL(iface->name));
return;
}
for (j = 0; j < num_interfaces; j++) {
if (interfaces[j] == iface) {
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
if (j >= num_parent_interfaces) {
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
efree(interfaces);
Improve error message class type Refer to interfaces/enums instead of classes in more places. Closes GH-7792 Closes GH-8187
2022-03-10 21:41:07 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "%s %s cannot implement previously implemented interface %s",
zend_get_object_type_uc(ce),
ZSTR_VAL(ce->name),
ZSTR_VAL(iface->name));
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
return;
}
/* skip duplications */
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&iface->constants_table, key, c) {
Add support for final class constants RFC: https://wiki.php.net/rfc/final_class_const Co-authored-by: Nikita Popov <nikita.ppv@gmail.com>
2021-07-07 03:38:44 +08:00
do_inherit_constant_check(ce, c, key);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
} ZEND_HASH_FOREACH_END();
iface = NULL;
break;
}
}
if (iface) {
interfaces[num_interfaces] = iface;
num_interfaces++;
}
}
Mark classes cached by opcache by ZEND_ACC_CACHED flag and prevent useless copying and desrpoying of immutable data.
2021-01-19 16:55:09 +08:00
if (!(ce->ce_flags & ZEND_ACC_CACHED)) {
for (i = 0; i < ce->num_interfaces; i++) {
zend_string_release_ex(ce->interface_names[i].name, 0);
zend_string_release_ex(ce->interface_names[i].lc_name, 0);
}
efree(ce->interface_names);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
}
ce->num_interfaces = num_interfaces;
ce->interfaces = interfaces;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
ce->ce_flags |= ZEND_ACC_RESOLVED_INTERFACES;
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
Implement interfaces after all methods available The place where interface implementation handlers is called is currently ill-defined: If the class implements interfaces itself, the handlers for both the parent interfaces and the new interfaces will be called after all methods are registered (post trait use). If the class does not implement interfaces, then the parent interface handlers are called early during inheritance (before methods are inherited). This commit moves the calls to always occur after all methods are available. For userland classes this will be post trait import, at the time where interfaces get implemented (whether the class itself defines additional interfaces or not). For internal classes it will be at the end of inheritance, as internal class declarations do not have proper finalization. This allows us to simplify the logic for implementing the magic Iterator / IteratorAggregate interfaces. In particularly we can now also automatically detect whether an extension of IteratorAggregate can safely reuse a custom get_iterator handler, or whether it needs to switch to the userland mechanism. The Iterator case continues to rely on ZEND_ACC_REUSE_GET_ITERATOR for this purpose, as a wholesale replacement is not possible there.
2020-03-04 17:10:36 +08:00
for (i = 0; i < num_parent_interfaces; i++) {
do_implement_interface(ce, ce->interfaces[i]);
}
Avoid duplicate calls to interface implementation handler
2020-02-28 19:16:41 +08:00
/* Note that new interfaces can be added during this loop due to interface inheritance.
* Use num_interfaces rather than ce->num_interfaces to not re-process the new ones. */
for (; i < num_interfaces; i++) {
Separate common code abd eliminate useless checks
2019-06-27 18:11:08 +08:00
do_interface_implementation(ce, ce->interfaces[i]);
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
static zend_class_entry *fixup_trait_scope(const zend_function *fn, zend_class_entry *ce)
{
/* self in trait methods should be resolved to the using class, not the trait. */
return fn->common.scope->ce_flags & ZEND_ACC_TRAIT ? ce : fn->common.scope;
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
static void zend_add_trait_method(zend_class_entry *ce, zend_string *name, zend_string *key, zend_function *fn) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
zend_function *existing_fn = NULL;
zend_function *new_fn;
if ((existing_fn = zend_hash_find_ptr(&ce->function_table, key)) != NULL) {
Fix #76773 - Methods with a concrete scope need to be added again
2018-08-22 00:40:06 +08:00
/* if it is the same function with the same visibility and has not been assigned a class scope yet, regardless
* of where it is coming from there is no conflict and we do not need to add it again */
Fix #76700 - Methods with altered visibility need to be added again
2018-08-04 00:30:03 +08:00
if (existing_fn->op_array.opcodes == fn->op_array.opcodes &&
Fix #76773 - Methods with a concrete scope need to be added again
2018-08-22 00:40:06 +08:00
(existing_fn->common.fn_flags & ZEND_ACC_PPP_MASK) == (fn->common.fn_flags & ZEND_ACC_PPP_MASK) &&
(existing_fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
63911: Compare opcodes of the op_array to determine different functions
2017-10-01 04:24:38 +08:00
return;
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
/* Abstract method signatures from the trait must be satisfied. */
if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
/* "abstract private" methods in traits were not available prior to PHP 8.
* As such, "abstract protected" was sometimes used to indicate trait requirements,
* even though the "implementing" method was private. Do not check visibility
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
* requirements to maintain backwards-compatibility with such usage.
*/
do_inheritance_check_on_method(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
existing_fn, fixup_trait_scope(existing_fn, ce), fn, fixup_trait_scope(fn, ce),
ce, NULL, /* check_visibility */ 0);
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
return;
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (existing_fn->common.scope == ce) {
/* members from the current class override trait methods */
return;
Fixed bug #78776 By using the normal inheritance check if the parent is abstract as well.
2019-12-18 22:53:09 +08:00
} else if (UNEXPECTED((existing_fn->common.scope->ce_flags & ZEND_ACC_TRAIT)
&& !(existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT))) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* two traits can't define the same non-abstract method */
zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s::%s has not been applied as %s::%s, because of collision with %s::%s",
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
ZSTR_VAL(fn->common.scope->name), ZSTR_VAL(fn->common.function_name),
Store aliased name of trait method Currently, trait methods are aliased will continue to use the original function name. In a few places in the codebase, we will try to look up the actual method name instead. However, this does not work if an aliased method is used indirectly (https://bugs.php.net/bug.php?id=69180). I think it would be better to instead actually change the method name to the alias. This is in principle easy: We have to allow function_name to be changed even if op array is otherwise shared (similar to static_variables). This means we need to addref/release the function_name separately, but I don't think there is a performance concern here (especially as everything is usually interned). There is a bit of complication in opcache, where we need to make sure that the function name is released the correct number of times (interning may overwrite the name in the original op_array, but we need to release it as many times as the op_array is shared). Fixes bug #69180. Fixes bug #74939. Closes GH-5226.
2020-03-02 18:07:57 +08:00
ZSTR_VAL(ce->name), ZSTR_VAL(name),
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
ZSTR_VAL(existing_fn->common.scope->name), ZSTR_VAL(existing_fn->common.function_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
/* Inherited members are overridden by members inserted by traits.
* Check whether the trait method fulfills the inheritance requirements. */
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
do_inheritance_check_on_method(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
fn, fixup_trait_scope(fn, ce), existing_fn, fixup_trait_scope(existing_fn, ce),
ce, NULL, /* check_visibility */ 1);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Fixed incorrect ZEND_ACC_ARENA_ALLOCATED usage (it must be used only for internal functions).
2018-08-30 04:40:17 +08:00
if (UNEXPECTED(fn->type == ZEND_INTERNAL_FUNCTION)) {
new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_internal_function));
memcpy(new_fn, fn, sizeof(zend_internal_function));
new_fn->common.fn_flags |= ZEND_ACC_ARENA_ALLOCATED;
} else {
new_fn = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
memcpy(new_fn, fn, sizeof(zend_op_array));
Fixed issues related to optimization and persitence of classes linked with interfaces, traits or internal classes.
2018-11-14 21:32:07 +08:00
new_fn->op_array.fn_flags |= ZEND_ACC_TRAIT_CLONE;
Immutable clases and op_arrays. Squashed commit of the following: commit cd0c36c3f943849e5b97a8dbe2dd029fbeab3df9 Merge: 4740dabb84 ad6738e886 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:43:38 2018 +0300 Merge branch 'master' into immutable * master: Remove the "auto" encoding Fixed bug #77025 Add vtbls for EUC-TW encoding commit 4740dabb843c6d4f7f866b4a2456073c9eaf4c77 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 14:12:28 2018 +0300 Reverted back ce->iterator_funcs_ptr. Initialize ce->iterator_funcs_ptr fields in immutable classes. commit ad7a78b253be970db70c2251e66f9297d8e7f829 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:46:30 2018 +0300 Added comment commit 0276ea51875bab37be01a4dc5e5a047c5698c571 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:42:43 2018 +0300 Added type cast commit c63fc5d5f19c58498108d1698055b2b442227eb3 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:36:51 2018 +0300 Moved static class members initialization into the proper place. commit b945548e9306b1826c881918858b5e5aa3eb3002 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:21:03 2018 +0300 Removed redundand assertion commit d5a41088401814c829847db212488f8aae39bcd2 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:19:13 2018 +0300 Removed duplicate code commit 8dadca8864e66de70a24bdf1181bcf7dd8fb27d7 Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 11:05:43 2018 +0300 Hide offset encoding magic in ZEND_MAP_PTR_IS_OFFSET(), ZEND_MAP_PTR_OFFSET2PTR() and ZEND_MAP_PTR_PTR2OFFSET() macros. commit 9ef07c88bd76801e2d4fbfeab3ebfd6e6a67ac5f Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:48:29 2018 +0300 typo commit a06f0f3d3aba53e766046221ee44fb9720389ecc Merge: 94099586ec 3412345ffe Author: Dmitry Stogov <dmitry@zend.com> Date: Wed Oct 17 10:47:07 2018 +0300 Merge branch 'master' into immutable * master: Remove unused variable makefile_am_files Classify object handlers are required/optional Add support for getting SKIP_TAGSTART and SKIP_WHITE options Remove some obsolete config_vars.mk occurrences Remove bsd_converted from .gitignore Remove configuration parser and scanners ignores Remove obsolete buildconf.stamp from .gitignore [ci skip] Add magicdata.patch exception to .gitignore Remove outdated ext/spl/examples items from .gitignore Remove unused test.inc in ext/iconv/tests commit 94099586ec599117581ca01c15b1f6c5f749e23a Author: Dmitry Stogov <dmitry@zend.com> Date: Mon Oct 15 23:34:01 2018 +0300 Immutable clases and op_arrays
2018-10-17 20:52:50 +08:00
new_fn->op_array.fn_flags &= ~ZEND_ACC_IMMUTABLE;
Fixed incorrect ZEND_ACC_ARENA_ALLOCATED usage (it must be used only for internal functions).
2018-08-30 04:40:17 +08:00
}
Store aliased name of trait method Currently, trait methods are aliased will continue to use the original function name. In a few places in the codebase, we will try to look up the actual method name instead. However, this does not work if an aliased method is used indirectly (https://bugs.php.net/bug.php?id=69180). I think it would be better to instead actually change the method name to the alias. This is in principle easy: We have to allow function_name to be changed even if op array is otherwise shared (similar to static_variables). This means we need to addref/release the function_name separately, but I don't think there is a performance concern here (especially as everything is usually interned). There is a bit of complication in opcache, where we need to make sure that the function name is released the correct number of times (interning may overwrite the name in the original op_array, but we need to release it as many times as the op_array is shared). Fixes bug #69180. Fixes bug #74939. Closes GH-5226.
2020-03-02 18:07:57 +08:00
/* Reassign method name, in case it is an alias. */
new_fn->common.function_name = name;
Call function_add_ref() in proper place
2018-10-30 20:08:45 +08:00
function_add_ref(new_fn);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
fn = zend_hash_update_ptr(&ce->function_table, key, new_fn);
Add common code for magic method assignment This was repeated three times.
2020-07-20 20:56:48 +08:00
zend_add_magic_method(ce, fn, key);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
static void zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce) /* {{{ */
{
if ((fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
fn->common.scope = ce;
if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
}
Fixed #69566 in master
2015-05-04 10:35:55 +08:00
if (fn->type == ZEND_USER_FUNCTION && fn->op_array.static_variables) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
ce->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
}
}
}
/* }}} */
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
static void zend_traits_copy_functions(zend_string *fnname, zend_function *fn, zend_class_entry *ce, HashTable *exclude_table, zend_class_entry **aliases) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
zend_trait_alias *alias, **alias_ptr;
zend_string *lcname;
zend_function fn_copy;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
int i;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* apply aliases which are qualified with a class name, there should not be any ambiguity */
if (ce->trait_aliases) {
alias_ptr = ce->trait_aliases;
alias = *alias_ptr;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i = 0;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
while (alias) {
/* Scope unset or equal to the function we compare to, and the alias applies to fn */
if (alias->alias != NULL
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
&& fn->common.scope == aliases[i]
&& zend_string_equals_ci(alias->trait_method.method_name, fnname)
) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
fn_copy = *fn;
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
/* if it is 0, no modifiers have been changed */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (alias->modifiers) {
Small code cleanup I found what the modifier code does with XOR pretty confusing. It's just removing the PPP bits... Also remove an outdated reference to OVERLOADED_FUNCTION.
2020-03-03 22:00:15 +08:00
fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags & ~ZEND_ACC_PPP_MASK);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Added new API function 'zend_string* zend_string_tolower(zend_string*)'. It simplifies code and avoids unnecessary allocation and copying if string is already in lower case.
2014-12-24 20:04:51 +08:00
lcname = zend_string_tolower(alias->alias);
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_add_trait_method(ce, alias->alias, lcname, &fn_copy);
Use zend_string_release_ex() instread of zend_string_release() in places, where we sure about string persistence.
2018-05-28 21:27:12 +08:00
zend_string_release_ex(lcname, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
alias_ptr++;
alias = *alias_ptr;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i++;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
if (exclude_table == NULL || zend_hash_find(exclude_table, fnname) == NULL) {
/* is not in hashtable, thus, function is not to be excluded */
Small code cleanup I found what the modifier code does with XOR pretty confusing. It's just removing the PPP bits... Also remove an outdated reference to OVERLOADED_FUNCTION.
2020-03-03 22:00:15 +08:00
memcpy(&fn_copy, fn, fn->type == ZEND_USER_FUNCTION ? sizeof(zend_op_array) : sizeof(zend_internal_function));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* apply aliases which have not alias name, just setting visibility */
if (ce->trait_aliases) {
alias_ptr = ce->trait_aliases;
alias = *alias_ptr;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i = 0;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
while (alias) {
/* Scope unset or equal to the function we compare to, and the alias applies to fn */
if (alias->alias == NULL && alias->modifiers != 0
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
&& fn->common.scope == aliases[i]
&& zend_string_equals_ci(alias->trait_method.method_name, fnname)
) {
Small code cleanup I found what the modifier code does with XOR pretty confusing. It's just removing the PPP bits... Also remove an outdated reference to OVERLOADED_FUNCTION.
2020-03-03 22:00:15 +08:00
fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags & ~ZEND_ACC_PPP_MASK);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
alias_ptr++;
alias = *alias_ptr;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i++;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_add_trait_method(ce, fn->common.function_name, fnname, &fn_copy);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static uint32_t zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait, zend_class_entry **traits) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
uint32_t i;
Improved method inhereitance code and cleanup
2015-03-05 07:10:38 +08:00
if (UNEXPECTED((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT)) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", ZSTR_VAL(trait->name));
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
return 0;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
for (i = 0; i < ce->num_traits; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (traits[i] == trait) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
return i;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", ZSTR_VAL(trait->name), ZSTR_VAL(ce->name));
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
return 0;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static void zend_traits_init_trait_structures(zend_class_entry *ce, zend_class_entry **traits, HashTable ***exclude_tables_ptr, zend_class_entry ***aliases_ptr) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
size_t i, j = 0;
Merge branch 'PHP-5.6'
2015-03-05 21:06:59 +08:00
zend_trait_precedence **precedences;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_trait_precedence *cur_precedence;
zend_trait_method_reference *cur_method_ref;
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
zend_string *lc_trait_name;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_string *lcname;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
HashTable **exclude_tables = NULL;
zend_class_entry **aliases = NULL;
zend_class_entry *trait;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* resolve class references */
if (ce->trait_precedences) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
exclude_tables = ecalloc(ce->num_traits, sizeof(HashTable*));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
i = 0;
Merge branch 'PHP-5.6'
2015-03-05 21:06:59 +08:00
precedences = ce->trait_precedences;
ce->trait_precedences = NULL;
while ((cur_precedence = precedences[i])) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/** Resolve classes for all precedence operations. */
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
cur_method_ref = &cur_precedence->trait_method;
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
lc_trait_name = zend_string_tolower(cur_method_ref->class_name);
trait = zend_hash_find_ptr(EG(class_table), lc_trait_name);
zend_string_release_ex(lc_trait_name, 0);
Fix handling of unknown class in trait precedence list Fixes oss-fuzz #31983.
2021-03-19 23:04:16 +08:00
if (!trait || !(trait->ce_flags & ZEND_ACC_LINKED)) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(cur_method_ref->class_name));
}
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_check_trait_usage(ce, trait, traits);
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
/** Ensure that the preferred method is actually available. */
lcname = zend_string_tolower(cur_method_ref->method_name);
Micro-optimization
2018-09-19 18:54:37 +08:00
if (!zend_hash_exists(&trait->function_table, lcname)) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
zend_error_noreturn(E_COMPILE_ERROR,
"A precedence rule was defined for %s::%s but this method does not exist",
ZSTR_VAL(trait->name),
ZSTR_VAL(cur_method_ref->method_name));
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
/** With the other traits, we are more permissive.
We do not give errors for those. This allows to be more
defensive in such definitions.
However, we want to make sure that the insteadof declaration
is consistent in itself.
*/
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
for (j = 0; j < cur_precedence->num_excludes; j++) {
zend_string* class_name = cur_precedence->exclude_class_names[j];
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
zend_class_entry *exclude_ce;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
uint32_t trait_num;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
lc_trait_name = zend_string_tolower(class_name);
exclude_ce = zend_hash_find_ptr(EG(class_table), lc_trait_name);
zend_string_release_ex(lc_trait_name, 0);
if (!exclude_ce || !(exclude_ce->ce_flags & ZEND_ACC_LINKED)) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(class_name));
}
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
trait_num = zend_check_trait_usage(ce, exclude_ce, traits);
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
if (!exclude_tables[trait_num]) {
ALLOC_HASHTABLE(exclude_tables[trait_num]);
zend_hash_init(exclude_tables[trait_num], 0, NULL, NULL, 0);
}
if (zend_hash_add_empty_element(exclude_tables[trait_num], lcname) == NULL) {
zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", ZSTR_VAL(precedences[i]->trait_method.method_name), ZSTR_VAL(exclude_ce->name));
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
/* make sure that the trait method is not from a class mentioned in
exclude_from_classes, for consistency */
if (trait == exclude_ce) {
zend_error_noreturn(E_COMPILE_ERROR,
"Inconsistent insteadof definition. "
"The method %s is to be used from %s, but %s is also on the exclude list",
ZSTR_VAL(cur_method_ref->method_name),
ZSTR_VAL(trait->name),
ZSTR_VAL(trait->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
zend_string_release_ex(lcname, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
i++;
}
Merge branch 'PHP-5.6'
2015-03-05 21:06:59 +08:00
ce->trait_precedences = precedences;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
if (ce->trait_aliases) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
i = 0;
while (ce->trait_aliases[i]) {
i++;
}
aliases = ecalloc(i, sizeof(zend_class_entry*));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
i = 0;
while (ce->trait_aliases[i]) {
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
zend_trait_alias *cur_alias = ce->trait_aliases[i];
cur_method_ref = &ce->trait_aliases[i]->trait_method;
lcname = zend_string_tolower(cur_method_ref->method_name);
if (cur_method_ref->class_name) {
/* For all aliases with an explicit class name, resolve the class now. */
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
lc_trait_name = zend_string_tolower(cur_method_ref->class_name);
trait = zend_hash_find_ptr(EG(class_table), lc_trait_name);
zend_string_release_ex(lc_trait_name, 0);
if (!trait || !(trait->ce_flags & ZEND_ACC_LINKED)) {
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", ZSTR_VAL(cur_method_ref->class_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_check_trait_usage(ce, trait, traits);
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
aliases[i] = trait;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
/* And, ensure that the referenced method is resolvable, too. */
Micro-optimization
2018-09-19 18:54:37 +08:00
if (!zend_hash_exists(&trait->function_table, lcname)) {
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", ZSTR_VAL(trait->name), ZSTR_VAL(cur_method_ref->method_name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
} else {
/* Find out which trait this method refers to. */
trait = NULL;
for (j = 0; j < ce->num_traits; j++) {
if (traits[j]) {
if (zend_hash_exists(&traits[j]->function_table, lcname)) {
if (!trait) {
trait = traits[j];
continue;
}
Require non-absolute trait method refs to be unambiguous Currently, when writing something like class X { use T1, T2 { func as otherFunc; } function func() {} } where both T1::func() and T2::func() exist, we will simply assume that func refers to T1::func(). This is surprising, and it doesn't really make sense that this particular method gets picked. This commit validates that non-absolute method references are unambiguous, i.e. refer to exactly one method. If there is ambiguity, it is required to write T1::func as otherFunc or similar. Closes GH-5232.
2020-03-03 21:31:09 +08:00
zend_error_noreturn(E_COMPILE_ERROR,
"An alias was defined for method %s(), which exists in both %s and %s. Use %s::%s or %s::%s to resolve the ambiguity",
ZSTR_VAL(cur_method_ref->method_name),
ZSTR_VAL(trait->name), ZSTR_VAL(traits[j]->name),
ZSTR_VAL(trait->name), ZSTR_VAL(cur_method_ref->method_name),
ZSTR_VAL(traits[j]->name), ZSTR_VAL(cur_method_ref->method_name));
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
}
}
}
/* Non-absolute method reference refers to method that does not exist. */
if (!trait) {
if (cur_alias->alias) {
zend_error_noreturn(E_COMPILE_ERROR,
"An alias (%s) was defined for method %s(), but this method does not exist",
ZSTR_VAL(cur_alias->alias),
ZSTR_VAL(cur_alias->trait_method.method_name));
} else {
zend_error_noreturn(E_COMPILE_ERROR,
"The modifiers of the trait method %s() are changed, but this method does not exist. Error",
ZSTR_VAL(cur_alias->trait_method.method_name));
}
}
aliases[i] = trait;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Resolve trait alias refers to earlier Make sure all trait method references are converted to absolute method references in advance. This regresses one error message that I don't think is particularly valuable.
2020-03-03 21:21:33 +08:00
zend_string_release_ex(lcname, 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
i++;
}
}
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
*exclude_tables_ptr = exclude_tables;
*aliases_ptr = aliases;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static void zend_do_traits_method_binding(zend_class_entry *ce, zend_class_entry **traits, HashTable **exclude_tables, zend_class_entry **aliases) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
uint32_t i;
zend_string *key;
zend_function *fn;
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
if (exclude_tables) {
for (i = 0; i < ce->num_traits; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (traits[i]) {
/* copies functions, applies defined aliasing, and excludes unused trait methods */
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_traits_copy_functions(key, fn, ce, exclude_tables[i], aliases);
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
} ZEND_HASH_FOREACH_END();
if (exclude_tables[i]) {
zend_hash_destroy(exclude_tables[i]);
FREE_HASHTABLE(exclude_tables[i]);
exclude_tables[i] = NULL;
}
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
}
}
} else {
for (i = 0; i < ce->num_traits; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (traits[i]) {
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&traits[i]->function_table, key, fn) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
zend_traits_copy_functions(key, fn, ce, NULL, aliases);
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
} ZEND_HASH_FOREACH_END();
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, fn) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_fixup_trait_method(fn, ce);
} ZEND_HASH_FOREACH_END();
}
/* }}} */
Implement constants in traits (#8888) RFC: https://wiki.php.net/rfc/constants_in_traits
2022-08-05 03:08:40 +08:00
static zend_class_entry* find_first_constant_definition(zend_class_entry *ce, zend_class_entry **traits, size_t current_trait, zend_string *constant_name, zend_class_entry *colliding_ce) /* {{{ */
{
/* This function is used to show the place of the existing conflicting
* definition in error messages when conflicts occur. Since trait constants
* are flattened into the constants table of the composing class, and thus
* we lose information about which constant was defined in which trait, a
* process like this is needed to find the location of the first definition
* of the constant from traits.
*/
size_t i;
if (colliding_ce == ce) {
for (i = 0; i < current_trait; i++) {
if (traits[i]
&& zend_hash_exists(&traits[i]->constants_table, constant_name)) {
return traits[i];
}
}
}
/* Traits don't have it, then the composing class (or trait) itself has it. */
return colliding_ce;
}
/* }}} */
static bool do_trait_constant_check(zend_class_entry *ce, zend_class_constant *trait_constant, zend_string *name, zend_class_entry **traits, size_t current_trait) /* {{{ */
{
uint32_t flags_mask = ZEND_ACC_PPP_MASK | ZEND_ACC_FINAL;
zval *zv = zend_hash_find_known_hash(&ce->constants_table, name);
if (zv == NULL) {
/* No existing constant of the same name, so this one can be added */
return true;
}
zend_class_constant *existing_constant = Z_PTR_P(zv);
if ((ZEND_CLASS_CONST_FLAGS(trait_constant) & flags_mask) != (ZEND_CLASS_CONST_FLAGS(existing_constant) & flags_mask) ||
!check_trait_property_or_constant_value_compatibility(ce, &trait_constant->value, &existing_constant->value)) {
/* There is an existing constant of the same name, and it conflicts with the new one, so let's throw a fatal error */
zend_error_noreturn(E_COMPILE_ERROR,
"%s and %s define the same constant (%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
ZSTR_VAL(find_first_constant_definition(ce, traits, current_trait, name, existing_constant->ce)->name),
ZSTR_VAL(trait_constant->ce->name),
ZSTR_VAL(name),
ZSTR_VAL(ce->name));
}
/* There is an existing constant which is compatible with the new one, so no need to add it */
return false;
}
/* }}} */
static void zend_do_traits_constant_binding(zend_class_entry *ce, zend_class_entry **traits) /* {{{ */
{
size_t i;
for (i = 0; i < ce->num_traits; i++) {
zend_string *constant_name;
zend_class_constant *constant;
if (!traits[i]) {
continue;
}
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&traits[i]->constants_table, constant_name, constant) {
if (do_trait_constant_check(ce, constant, constant_name, traits, i)) {
zend_class_constant *ct = NULL;
ct = zend_arena_alloc(&CG(arena),sizeof(zend_class_constant));
memcpy(ct, constant, sizeof(zend_class_constant));
constant = ct;
if (Z_TYPE(constant->value) == IS_CONSTANT_AST) {
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
ce->ce_flags |= ZEND_ACC_HAS_AST_CONSTANTS;
}
/* Unlike interface implementations and class inheritances,
* access control of the trait constants is done by the scope
* of the composing class. So let's replace the ce here.
*/
constant->ce = ce;
Z_TRY_ADDREF(constant->value);
constant->doc_comment = constant->doc_comment ? zend_string_copy(constant->doc_comment) : NULL;
if (constant->attributes && (!(GC_FLAGS(constant->attributes) & IS_ARRAY_IMMUTABLE))) {
GC_ADDREF(constant->attributes);
}
zend_hash_update_ptr(&ce->constants_table, constant_name, constant);
}
} ZEND_HASH_FOREACH_END();
}
}
/* }}} */
static zend_class_entry* find_first_property_definition(zend_class_entry *ce, zend_class_entry **traits, size_t current_trait, zend_string *prop_name, zend_class_entry *colliding_ce) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
size_t i;
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
if (colliding_ce == ce) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
for (i = 0; i < current_trait; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (traits[i]
&& zend_hash_exists(&traits[i]->properties_info, prop_name)) {
return traits[i];
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
}
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
return colliding_ce;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
/* }}} */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
static void zend_do_traits_property_binding(zend_class_entry *ce, zend_class_entry **traits) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
size_t i;
zend_property_info *property_info;
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
zend_property_info *colliding_prop;
Add Attributes Co-authored-by: Martin Schröder <m.schroeder2007@gmail.com>
2020-05-25 02:57:00 +08:00
zend_property_info *new_prop;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_string* prop_name;
zval* prop_value;
zend_string *doc_comment;
/* In the following steps the properties are inserted into the property table
* for that, a very strict approach is applied:
* - check for compatibility, if not compatible with any property in class -> fatal
* - if compatible, then strict notice
*/
for (i = 0; i < ce->num_traits; i++) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
if (!traits[i]) {
continue;
}
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&traits[i]->properties_info, prop_name, property_info) {
Remove unnecessary property unmangling in trait binding The unmangled name is already available as the hashtable key, use it directly.
2021-03-26 19:14:32 +08:00
uint32_t flags = property_info->flags;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* next: check for conflicts with current class */
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
if ((colliding_prop = zend_hash_find_ptr(&ce->properties_info, prop_name)) != NULL) {
if ((colliding_prop->flags & ZEND_ACC_PRIVATE) && colliding_prop->ce != ce) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_hash_del(&ce->properties_info, prop_name);
flags |= ZEND_ACC_CHANGED;
} else {
Implement constants in traits (#8888) RFC: https://wiki.php.net/rfc/constants_in_traits
2022-08-05 03:08:40 +08:00
bool is_compatible = false;
Implement readonly properties Add support for readonly properties, for which only a single initializing assignment from the declaring scope is allowed. RFC: https://wiki.php.net/rfc/readonly_properties_v2 Closes GH-7089.
2021-06-02 16:02:56 +08:00
uint32_t flags_mask = ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC | ZEND_ACC_READONLY;
Trailing whitespaces Signed-off-by: Gabriel Caruso <carusogabriel34@gmail.com>
2017-12-31 12:35:25 +08:00
Implement readonly properties Add support for readonly properties, for which only a single initializing assignment from the declaring scope is allowed. RFC: https://wiki.php.net/rfc/readonly_properties_v2 Closes GH-7089.
2021-06-02 16:02:56 +08:00
if ((colliding_prop->flags & flags_mask) == (flags & flags_mask) &&
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
property_types_compatible(property_info, colliding_prop) == INHERITANCE_SUCCESS
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
) {
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 08:31:03 +08:00
/* the flags are identical, thus, the properties may be compatible */
Fix #75607 - Check if existing static trait property is a ref before comparing
2017-12-02 00:08:11 +08:00
zval *op1, *op2;
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 08:31:03 +08:00
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
if (flags & ZEND_ACC_STATIC) {
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
op1 = &ce->default_static_members_table[colliding_prop->offset];
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
op2 = &traits[i]->default_static_members_table[property_info->offset];
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
ZVAL_DEINDIRECT(op1);
ZVAL_DEINDIRECT(op2);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
op1 = &ce->default_properties_table[OBJ_PROP_TO_NUM(colliding_prop->offset)];
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
op2 = &traits[i]->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)];
Fix #74922 - Try to resolve constants when importing trait properties
2017-09-27 08:31:03 +08:00
}
Implement constants in traits (#8888) RFC: https://wiki.php.net/rfc/constants_in_traits
2022-08-05 03:08:40 +08:00
is_compatible = check_trait_property_or_constant_value_compatibility(ce, op1, op2);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Implement constants in traits (#8888) RFC: https://wiki.php.net/rfc/constants_in_traits
2022-08-05 03:08:40 +08:00
if (!is_compatible) {
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
zend_error_noreturn(E_COMPILE_ERROR,
Fix GH-9285 Traits cannot be used in readonly classes
2022-08-21 16:29:51 +08:00
"%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
Implement constants in traits (#8888) RFC: https://wiki.php.net/rfc/constants_in_traits
2022-08-05 03:08:40 +08:00
ZSTR_VAL(find_first_property_definition(ce, traits, i, prop_name, colliding_prop->ce)->name),
Use ZSTR_ API to access zend_string elements (this is just renaming without semantick changes).
2015-06-30 18:59:27 +08:00
ZSTR_VAL(property_info->ce->name),
ZSTR_VAL(prop_name),
ZSTR_VAL(ce->name));
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
Reclassify E_STRICT notices Per RFC https://wiki.php.net/rfc/reclassify_e_strict While reviewing this, found that there are still three E_STRICTs left in libraries - need to discuss those.
2015-03-15 16:47:25 +08:00
continue;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
}
Fix GH-9285 Traits cannot be used in readonly classes
2022-08-21 16:29:51 +08:00
if ((ce->ce_flags & ZEND_ACC_READONLY_CLASS) && !(property_info->flags & ZEND_ACC_READONLY)) {
zend_error_noreturn(E_COMPILE_ERROR,
"Readonly class %s cannot use trait with a non-readonly property %s::$%s",
ZSTR_VAL(ce->name),
ZSTR_VAL(property_info->ce->name),
ZSTR_VAL(prop_name)
);
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* property not found, so lets add it */
if (flags & ZEND_ACC_STATIC) {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
prop_value = &traits[i]->default_static_members_table[property_info->offset];
Fixed bug #76509 In PHP static properties are shared between inheriting classes, unless they are explicitly overwritten. However, because this functionality was implemented using reference, it was possible to break the implementation by reassigning the static property reference. This is fixed by switching the implementation from using references to using INDIRECTs, which cannot be affected by userland code.
2018-06-22 18:58:48 +08:00
ZEND_ASSERT(Z_TYPE_P(prop_value) != IS_INDIRECT);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} else {
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
prop_value = &traits[i]->default_properties_table[OBJ_PROP_TO_NUM(property_info->offset)];
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
}
RC manipulation cleanup
2017-11-01 10:25:10 +08:00
Z_TRY_ADDREF_P(prop_value);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
doc_comment = property_info->doc_comment ? zend_string_copy(property_info->doc_comment) : NULL;
Add Attributes Co-authored-by: Martin Schröder <m.schroeder2007@gmail.com>
2020-05-25 02:57:00 +08:00
Fix use of type copy ctor when importing trait properties We shouldn't call the copy constructor inside the original type, duh.
2020-11-03 22:29:18 +08:00
zend_type type = property_info->type;
zend_type_copy_ctor(&type, /* persistent */ 0);
new_prop = zend_declare_typed_property(ce, prop_name, prop_value, flags, doc_comment, type);
Add Attributes Co-authored-by: Martin Schröder <m.schroeder2007@gmail.com>
2020-05-25 02:57:00 +08:00
if (property_info->attributes) {
new_prop->attributes = property_info->attributes;
if (!(GC_FLAGS(new_prop->attributes) & IS_ARRAY_IMMUTABLE)) {
GC_ADDREF(new_prop->attributes);
}
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
} ZEND_HASH_FOREACH_END();
}
}
/* }}} */
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
static void zend_do_bind_traits(zend_class_entry *ce, zend_class_entry **traits) /* {{{ */
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
{
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
HashTable **exclude_tables;
zend_class_entry **aliases;
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Keep information about unresolved interfaces in zend_class_entry->interface_names. Move interface implementation code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_INTERFACE and ZEND_VERIFY_ABSTRACT_CLASS opcodes.
2018-08-23 22:16:28 +08:00
ZEND_ASSERT(ce->num_traits > 0);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Fix spelling and grammar mistakes This PR corrects misspellings identified by the check-spelling action. The misspellings have been reported at jsoref@b6ba3e2#commitcomment-48946465 The action reports that the changes in this PR would make it happy: jsoref@602417c Closes GH-6822.
2021-03-31 11:49:41 +08:00
/* complete initialization of trait structures in ce */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_traits_init_trait_structures(ce, traits, &exclude_tables, &aliases);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
/* first care about all methods to be flattened into the class */
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_do_traits_method_binding(ce, traits, exclude_tables, aliases);
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Changed structure of zend_class_entry.trait_aliases and zend_class_entry.trait_precedences to avoid keeping "intermediate" trait references, that are used only during inheritance.
2018-07-11 23:56:10 +08:00
if (aliases) {
efree(aliases);
}
if (exclude_tables) {
efree(exclude_tables);
}
Split inheritance into separate file This moves handling of inheritance and interface implementation from zend_compile.c into a separate zend_inheritance.c file, as this is not really related to compilation.
2014-09-19 06:01:05 +08:00
Implement constants in traits (#8888) RFC: https://wiki.php.net/rfc/constants_in_traits
2022-08-05 03:08:40 +08:00
/* then flatten the constants and properties into it, to, mostly to notify developer about problems */
zend_do_traits_constant_binding(ce, traits);
Replace zend_class_entry->traits by persistent zend_class_entry->trait_names. Move trait binding code into ZEND_DECLARE_*CLASS opcodes. Remove ZEND_ADD_TRIAIT and ZEND_BIND_TRAITS opcodes.
2018-08-23 07:02:26 +08:00
zend_do_traits_property_binding(ce, traits);
Deprecate PHP 4 constructors
2015-03-31 22:10:22 +08:00
}
/* }}} */
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
#define MAX_ABSTRACT_INFO_CNT 3
#define MAX_ABSTRACT_INFO_FMT "%s%s%s%s"
#define DISPLAY_ABSTRACT_FN(idx) \
ai.afn[idx] ? ZEND_FN_SCOPE_NAME(ai.afn[idx]) : "", \
ai.afn[idx] ? "::" : "", \
ai.afn[idx] ? ZSTR_VAL(ai.afn[idx]->common.function_name) : "", \
ai.afn[idx] && ai.afn[idx + 1] ? ", " : (ai.afn[idx] && ai.cnt > MAX_ABSTRACT_INFO_CNT ? ", ..." : "")
typedef struct _zend_abstract_info {
zend_function *afn[MAX_ABSTRACT_INFO_CNT + 1];
int cnt;
} zend_abstract_info;
static void zend_verify_abstract_class_function(zend_function *fn, zend_abstract_info *ai) /* {{{ */
{
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (ai->cnt < MAX_ABSTRACT_INFO_CNT) {
ai->afn[ai->cnt] = fn;
}
Remove special ctor handling in abstract class verification This seems to be some kind of leftover from PHP 4 ctor support.
2021-07-27 16:16:09 +08:00
ai->cnt++;
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
}
/* }}} */
void zend_verify_abstract_class(zend_class_entry *ce) /* {{{ */
{
zend_function *func;
zend_abstract_info ai;
Replace zend_bool uses with bool We're starting to see a mix between uses of zend_bool and bool. Replace all usages with the standard bool type everywhere. Of course, zend_bool is retained as an alias.
2021-01-15 19:30:54 +08:00
bool is_explicit_abstract = (ce->ce_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS) != 0;
Improve error message class type Refer to interfaces/enums instead of classes in more places. Closes GH-7792 Closes GH-8187
2022-03-10 21:41:07 +08:00
bool can_be_abstract = (ce->ce_flags & ZEND_ACC_ENUM) == 0;
Cleanup class linking
2018-08-27 21:40:25 +08:00
memset(&ai, 0, sizeof(ai));
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_PTR(&ce->function_table, func) {
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
if (func->common.fn_flags & ZEND_ACC_ABSTRACT) {
/* If the class is explicitly abstract, we only check private abstract methods,
* because only they must be declared in the same class. */
if (!is_explicit_abstract || (func->common.fn_flags & ZEND_ACC_PRIVATE)) {
zend_verify_abstract_class_function(func, &ai);
}
}
Cleanup class linking
2018-08-27 21:40:25 +08:00
} ZEND_HASH_FOREACH_END();
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
Cleanup class linking
2018-08-27 21:40:25 +08:00
if (ai.cnt) {
Improve error message class type Refer to interfaces/enums instead of classes in more places. Closes GH-7792 Closes GH-8187
2022-03-10 21:41:07 +08:00
zend_error_noreturn(E_ERROR, !is_explicit_abstract && can_be_abstract
? "%s %s contains %d abstract method%s and must therefore be declared abstract or implement the remaining methods (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")"
: "%s %s must implement %d abstract private method%s (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")",
zend_get_object_type_uc(ce),
Cleanup class linking
2018-08-27 21:40:25 +08:00
ZSTR_VAL(ce->name), ai.cnt,
ai.cnt > 1 ? "s" : "",
DISPLAY_ABSTRACT_FN(0),
DISPLAY_ABSTRACT_FN(1),
DISPLAY_ABSTRACT_FN(2)
);
} else {
/* now everything should be fine and an added ZEND_ACC_IMPLICIT_ABSTRACT_CLASS should be removed */
ce->ce_flags &= ~ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
}
}
/* }}} */
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
typedef struct {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
enum {
OBLIGATION_DEPENDENCY,
OBLIGATION_COMPATIBILITY,
OBLIGATION_PROPERTY_COMPATIBILITY
} type;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
union {
zend_class_entry *dependency_ce;
struct {
Fixed bug #78989 Always operate on copies of the functions, so we don't reference temporary trait methods that have gone out of scope. This could be more efficient, but doing an allocated copy only when strictly necessary turned out to be somewhat tricky.
2020-01-28 17:41:11 +08:00
/* Traits may use temporary on-stack functions during inheritance checks,
* so use copies of functions here as well. */
zend_function parent_fn;
zend_function child_fn;
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_class_entry *child_scope;
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
zend_class_entry *parent_scope;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
};
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
struct {
const zend_property_info *parent_prop;
const zend_property_info *child_prop;
};
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
};
} variance_obligation;
static void variance_obligation_dtor(zval *zv) {
efree(Z_PTR_P(zv));
}
static void variance_obligation_ht_dtor(zval *zv) {
zend_hash_destroy(Z_PTR_P(zv));
FREE_HASHTABLE(Z_PTR_P(zv));
}
static HashTable *get_or_init_obligations_for_class(zend_class_entry *ce) {
HashTable *ht;
zend_ulong key;
if (!CG(delayed_variance_obligations)) {
ALLOC_HASHTABLE(CG(delayed_variance_obligations));
zend_hash_init(CG(delayed_variance_obligations), 0, NULL, variance_obligation_ht_dtor, 0);
}
key = (zend_ulong) (uintptr_t) ce;
ht = zend_hash_index_find_ptr(CG(delayed_variance_obligations), key);
if (ht) {
return ht;
}
ALLOC_HASHTABLE(ht);
zend_hash_init(ht, 0, NULL, variance_obligation_dtor, 0);
zend_hash_index_add_new_ptr(CG(delayed_variance_obligations), key, ht);
ce->ce_flags |= ZEND_ACC_UNRESOLVED_VARIANCE;
return ht;
}
static void add_dependency_obligation(zend_class_entry *ce, zend_class_entry *dependency_ce) {
HashTable *obligations = get_or_init_obligations_for_class(ce);
variance_obligation *obligation = emalloc(sizeof(variance_obligation));
obligation->type = OBLIGATION_DEPENDENCY;
obligation->dependency_ce = dependency_ce;
zend_hash_next_index_insert_ptr(obligations, obligation);
}
static void add_compatibility_obligation(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
zend_class_entry *ce,
const zend_function *child_fn, zend_class_entry *child_scope,
const zend_function *parent_fn, zend_class_entry *parent_scope) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
HashTable *obligations = get_or_init_obligations_for_class(ce);
variance_obligation *obligation = emalloc(sizeof(variance_obligation));
obligation->type = OBLIGATION_COMPATIBILITY;
Fix copying of functions in variance obligations Only copy sizeof(zend_internal_function) for internal functions.
2020-01-30 18:55:38 +08:00
/* Copy functions, because they may be stack-allocated in the case of traits. */
if (child_fn->common.type == ZEND_INTERNAL_FUNCTION) {
memcpy(&obligation->child_fn, child_fn, sizeof(zend_internal_function));
} else {
memcpy(&obligation->child_fn, child_fn, sizeof(zend_op_array));
}
if (parent_fn->common.type == ZEND_INTERNAL_FUNCTION) {
memcpy(&obligation->parent_fn, parent_fn, sizeof(zend_internal_function));
} else {
memcpy(&obligation->parent_fn, parent_fn, sizeof(zend_op_array));
}
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
obligation->child_scope = child_scope;
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
obligation->parent_scope = parent_scope;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
zend_hash_next_index_insert_ptr(obligations, obligation);
}
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
static void add_property_compatibility_obligation(
zend_class_entry *ce, const zend_property_info *child_prop,
const zend_property_info *parent_prop) {
HashTable *obligations = get_or_init_obligations_for_class(ce);
variance_obligation *obligation = emalloc(sizeof(variance_obligation));
obligation->type = OBLIGATION_PROPERTY_COMPATIBILITY;
obligation->child_prop = child_prop;
obligation->parent_prop = parent_prop;
zend_hash_next_index_insert_ptr(obligations, obligation);
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
static void resolve_delayed_variance_obligations(zend_class_entry *ce);
Combine variance obligation processing and error reporting I don't believe there's a reason anymore to first resolve all delayed variance obligations, and then report errors if any are left. We can report errors directly when resolving obligations.
2021-11-08 17:32:47 +08:00
static void check_variance_obligation(variance_obligation *obligation) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
if (obligation->type == OBLIGATION_DEPENDENCY) {
zend_class_entry *dependency_ce = obligation->dependency_ce;
if (dependency_ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE) {
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
zend_class_entry *orig_linking_class = CG(current_linking_class);
CG(current_linking_class) =
(dependency_ce->ce_flags & ZEND_ACC_CACHEABLE) ? dependency_ce : NULL;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
resolve_delayed_variance_obligations(dependency_ce);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
CG(current_linking_class) = orig_linking_class;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
} else if (obligation->type == OBLIGATION_COMPATIBILITY) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
inheritance_status status = zend_do_perform_implementation_check(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
&obligation->child_fn, obligation->child_scope,
&obligation->parent_fn, obligation->parent_scope);
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
Fix treatment of "self" when validating against trait method If we're validating a class method against a trait method, we need to treat "self" in the trait method as the class where the method is used. To achieve this, we need to thread the proto scope through all methods, so it can be provided separately from proto.common->scope.
2020-04-23 17:34:07 +08:00
emit_incompatible_method_error(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
&obligation->child_fn, obligation->child_scope,
&obligation->parent_fn, obligation->parent_scope, status);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
/* Either the compatibility check was successful or only threw a warning. */
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
} else {
ZEND_ASSERT(obligation->type == OBLIGATION_PROPERTY_COMPATIBILITY);
inheritance_status status =
property_types_compatible(obligation->parent_prop, obligation->child_prop);
if (status != INHERITANCE_SUCCESS) {
emit_incompatible_property_error(obligation->child_prop, obligation->parent_prop);
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
}
Convert exception during delayed autoload to fatal error Same as with other exceptions during inheritance, convert those thrown during delayed class loading into fatal errors. We can't properly deal with such exceptions, as inheritance cannot be gracefully aborted at this point. Fixes oss-fuzz #39405.
2021-09-29 16:01:05 +08:00
static void load_delayed_classes(zend_class_entry *ce) {
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
HashTable *delayed_autoloads = CG(delayed_autoloads);
if (!delayed_autoloads) {
return;
}
Fix bug #78647 We can't take ownership of the delayed autoload table here. It is important that pending classes get loaded before resolving variance of any nested classed, as they might actually be lower in the hierarchy.
2021-11-06 00:33:08 +08:00
/* Autoloading can trigger linking of another class, which may register new delayed autoloads.
* For that reason, this code uses a loop that pops and loads the first element of the HT. If
* this triggers linking, then the remaining classes may get loaded when linking the newly
* loaded class. This is important, as otherwise necessary dependencies may not be available
* if the new class is lower in the hierarchy than the current one. */
HashPosition pos = 0;
zend_string *name;
zend_ulong idx;
while (zend_hash_get_current_key_ex(delayed_autoloads, &name, &idx, &pos)
!= HASH_KEY_NON_EXISTENT) {
zend_string_addref(name);
zend_hash_del(delayed_autoloads, name);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
zend_lookup_class(name);
Fix bug #78647 We can't take ownership of the delayed autoload table here. It is important that pending classes get loaded before resolving variance of any nested classed, as they might actually be lower in the hierarchy.
2021-11-06 00:33:08 +08:00
zend_string_release(name);
Bail on exception during delayed autoload We shouldn't try to load further classes if one autoload throws. This fixes oss-fuzz #38881, though I believe there are still two deeper issues here: 1) Why do we allow autoloading with an active exception? 2) Exception save & restore should probably also save and restore the exception opline.
2021-09-23 18:44:51 +08:00
if (EG(exception)) {
Convert exception during delayed autoload to fatal error Same as with other exceptions during inheritance, convert those thrown during delayed class loading into fatal errors. We can't properly deal with such exceptions, as inheritance cannot be gracefully aborted at this point. Fixes oss-fuzz #39405.
2021-09-29 16:01:05 +08:00
zend_exception_uncaught_error(
"During inheritance of %s, while autoloading %s",
ZSTR_VAL(ce->name), ZSTR_VAL(name));
Bail on exception during delayed autoload We shouldn't try to load further classes if one autoload throws. This fixes oss-fuzz #38881, though I believe there are still two deeper issues here: 1) Why do we allow autoloading with an active exception? 2) Exception save & restore should probably also save and restore the exception opline.
2021-09-23 18:44:51 +08:00
}
Fix bug #78647 We can't take ownership of the delayed autoload table here. It is important that pending classes get loaded before resolving variance of any nested classed, as they might actually be lower in the hierarchy.
2021-11-06 00:33:08 +08:00
}
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
static void resolve_delayed_variance_obligations(zend_class_entry *ce) {
HashTable *all_obligations = CG(delayed_variance_obligations), *obligations;
zend_ulong num_key = (zend_ulong) (uintptr_t) ce;
ZEND_ASSERT(all_obligations != NULL);
obligations = zend_hash_index_find_ptr(all_obligations, num_key);
ZEND_ASSERT(obligations != NULL);
variance_obligation *obligation;
ZEND_HASH_FOREACH_PTR(obligations, obligation) {
Combine variance obligation processing and error reporting I don't believe there's a reason anymore to first resolve all delayed variance obligations, and then report errors if any are left. We can report errors directly when resolving obligations.
2021-11-08 17:32:47 +08:00
check_variance_obligation(obligation);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
} ZEND_HASH_FOREACH_END();
ce->ce_flags &= ~ZEND_ACC_UNRESOLVED_VARIANCE;
ce->ce_flags |= ZEND_ACC_LINKED;
zend_hash_index_del(all_obligations, num_key);
}
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
static void check_unrecoverable_load_failure(zend_class_entry *ce) {
/* If this class has been used while unlinked through a variance obligation, it is not legal
* to remove the class from the class table and throw an exception, because there is already
* a dependence on the inheritance hierarchy of this specific class. Instead we fall back to
* a fatal error, as would happen if we did not allow exceptions in the first place. */
Drop HAS_UNLINKED_USES flag Instead always use the unlinked_uses table, which is already used if opcache is used. Not much point in having a different mechanism for the non-opcache case.
2021-07-29 22:09:23 +08:00
if (CG(unlinked_uses)
&& zend_hash_index_del(CG(unlinked_uses), (zend_long)(zend_uintptr_t)ce) == SUCCESS) {
Convert exception during inheritance to fatal error Now that inheritance can throw deprecations again, these may be converted to exception by a custom error handler. In this case we need to convert the exception to a fatal error, as inheritance cannot safely throw in the general case.
2021-05-28 16:19:23 +08:00
zend_exception_uncaught_error(
"During inheritance of %s with variance dependencies", ZSTR_VAL(ce->name));
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
}
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
#define zend_update_inherited_handler(handler) do { \
if (ce->handler == (zend_function*)op_array) { \
ce->handler = (zend_function*)new_op_array; \
} \
} while (0)
static zend_class_entry *zend_lazy_class_load(zend_class_entry *pce)
{
zend_class_entry *ce;
Bucket *p, *end;
ce = zend_arena_alloc(&CG(arena), sizeof(zend_class_entry));
memcpy(ce, pce, sizeof(zend_class_entry));
ce->ce_flags &= ~ZEND_ACC_IMMUTABLE;
ce->refcount = 1;
ce->inheritance_cache = NULL;
Fix mutable data initialization during lazy class loading
2021-08-02 17:05:43 +08:00
if (CG(compiler_options) & ZEND_COMPILE_PRELOAD) {
ZEND_MAP_PTR_NEW(ce->mutable_data);
} else {
ZEND_MAP_PTR_INIT(ce->mutable_data, NULL);
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
/* properties */
if (ce->default_properties_table) {
zval *dst = emalloc(sizeof(zval) * ce->default_properties_count);
zval *src = ce->default_properties_table;
zval *end = src + ce->default_properties_count;
ce->default_properties_table = dst;
for (; src != end; src++, dst++) {
ZVAL_COPY_VALUE_PROP(dst, src);
}
}
/* methods */
ce->function_table.pDestructor = ZEND_FUNCTION_DTOR;
if (!(HT_FLAGS(&ce->function_table) & HASH_FLAG_UNINITIALIZED)) {
p = emalloc(HT_SIZE(&ce->function_table));
memcpy(p, HT_GET_DATA_ADDR(&ce->function_table), HT_USED_SIZE(&ce->function_table));
HT_SET_DATA_ADDR(&ce->function_table, p);
p = ce->function_table.arData;
end = p + ce->function_table.nNumUsed;
for (; p != end; p++) {
zend_op_array *op_array, *new_op_array;
op_array = Z_PTR(p->val);
ZEND_ASSERT(op_array->type == ZEND_USER_FUNCTION);
ZEND_ASSERT(op_array->scope == pce);
ZEND_ASSERT(op_array->prototype == NULL);
Avoid non-immutable map_ptr indirection
2021-10-14 17:16:18 +08:00
new_op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
Z_PTR(p->val) = new_op_array;
memcpy(new_op_array, op_array, sizeof(zend_op_array));
new_op_array->fn_flags &= ~ZEND_ACC_IMMUTABLE;
new_op_array->scope = ce;
Avoid non-immutable map_ptr indirection
2021-10-14 17:16:18 +08:00
ZEND_MAP_PTR_INIT(new_op_array->run_time_cache, NULL);
ZEND_MAP_PTR_INIT(new_op_array->static_variables_ptr, NULL);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
zend_update_inherited_handler(constructor);
zend_update_inherited_handler(destructor);
zend_update_inherited_handler(clone);
zend_update_inherited_handler(__get);
zend_update_inherited_handler(__set);
zend_update_inherited_handler(__call);
zend_update_inherited_handler(__isset);
zend_update_inherited_handler(__unset);
zend_update_inherited_handler(__tostring);
zend_update_inherited_handler(__callstatic);
zend_update_inherited_handler(__debugInfo);
zend_update_inherited_handler(__serialize);
zend_update_inherited_handler(__unserialize);
}
}
/* static members */
if (ce->default_static_members_table) {
zval *dst = emalloc(sizeof(zval) * ce->default_static_members_count);
zval *src = ce->default_static_members_table;
zval *end = src + ce->default_static_members_count;
ce->default_static_members_table = dst;
for (; src != end; src++, dst++) {
ZVAL_COPY_VALUE(dst, src);
}
}
Avoid non-immutable map_ptr indirection
2021-10-14 17:16:18 +08:00
ZEND_MAP_PTR_INIT(ce->static_members_table, NULL);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
/* properties_info */
if (!(HT_FLAGS(&ce->properties_info) & HASH_FLAG_UNINITIALIZED)) {
p = emalloc(HT_SIZE(&ce->properties_info));
memcpy(p, HT_GET_DATA_ADDR(&ce->properties_info), HT_USED_SIZE(&ce->properties_info));
HT_SET_DATA_ADDR(&ce->properties_info, p);
p = ce->properties_info.arData;
end = p + ce->properties_info.nNumUsed;
for (; p != end; p++) {
zend_property_info *prop_info, *new_prop_info;
prop_info = Z_PTR(p->val);
ZEND_ASSERT(prop_info->ce == pce);
new_prop_info= zend_arena_alloc(&CG(arena), sizeof(zend_property_info));
Z_PTR(p->val) = new_prop_info;
memcpy(new_prop_info, prop_info, sizeof(zend_property_info));
new_prop_info->ce = ce;
if (ZEND_TYPE_HAS_LIST(new_prop_info->type)) {
zend_type_list *new_list;
zend_type_list *list = ZEND_TYPE_LIST(new_prop_info->type);
new_list = zend_arena_alloc(&CG(arena), ZEND_TYPE_LIST_SIZE(list->num_types));
memcpy(new_list, list, ZEND_TYPE_LIST_SIZE(list->num_types));
ZEND_TYPE_SET_PTR(new_prop_info->type, list);
ZEND_TYPE_FULL_MASK(new_prop_info->type) |= _ZEND_TYPE_ARENA_BIT;
}
}
}
/* constants table */
if (!(HT_FLAGS(&ce->constants_table) & HASH_FLAG_UNINITIALIZED)) {
p = emalloc(HT_SIZE(&ce->constants_table));
memcpy(p, HT_GET_DATA_ADDR(&ce->constants_table), HT_USED_SIZE(&ce->constants_table));
HT_SET_DATA_ADDR(&ce->constants_table, p);
p = ce->constants_table.arData;
end = p + ce->constants_table.nNumUsed;
for (; p != end; p++) {
zend_class_constant *c, *new_c;
c = Z_PTR(p->val);
ZEND_ASSERT(c->ce == pce);
new_c = zend_arena_alloc(&CG(arena), sizeof(zend_class_constant));
Z_PTR(p->val) = new_c;
memcpy(new_c, c, sizeof(zend_class_constant));
new_c->ce = ce;
}
}
return ce;
}
#ifndef ZEND_WIN32
# define UPDATE_IS_CACHEABLE(ce) do { \
if ((ce)->type == ZEND_USER_CLASS) { \
is_cacheable &= (ce)->ce_flags; \
} \
} while (0)
#else
// TODO: ASLR may cause different addresses in different workers ???
# define UPDATE_IS_CACHEABLE(ce) do { \
is_cacheable &= (ce)->ce_flags; \
} while (0)
#endif
ZEND_API zend_class_entry *zend_do_link_class(zend_class_entry *ce, zend_string *lc_parent_name, zend_string *key) /* {{{ */
Cleanup class linking
2018-08-27 21:40:25 +08:00
{
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
/* Load parent/interface dependencies first, so we can still gracefully abort linking
* with an exception and remove the class from the class table. This is only possible
* if no variance obligations on the current class have been added during autoloading. */
zend_class_entry *parent = NULL;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
zend_class_entry **traits_and_interfaces = NULL;
zend_class_entry *proto = NULL;
zend_class_entry *orig_linking_class;
uint32_t is_cacheable = ce->ce_flags & ZEND_ACC_IMMUTABLE;
uint32_t i, j;
zval *zv;
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
ALLOCA_FLAG(use_heap)
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
Fixed compilation warning
2021-03-13 02:50:26 +08:00
SET_ALLOCA_FLAG(use_heap);
Link unbound simple classes (without parent/intefaces/traits) in first place.
2021-02-11 04:57:50 +08:00
ZEND_ASSERT(!(ce->ce_flags & ZEND_ACC_LINKED));
Register class before fetching parent We want the class declaration to be available while compiling the parent class.
2019-05-24 20:28:44 +08:00
if (ce->parent_name) {
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
parent = zend_fetch_class_by_name(
ce->parent_name, lc_parent_name,
ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED | ZEND_FETCH_CLASS_EXCEPTION);
if (!parent) {
check_unrecoverable_load_failure(ce);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
return NULL;
}
UPDATE_IS_CACHEABLE(parent);
}
if (ce->num_traits || ce->num_interfaces) {
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
traits_and_interfaces = do_alloca(sizeof(zend_class_entry*) * (ce->num_traits + ce->num_interfaces), use_heap);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
for (i = 0; i < ce->num_traits; i++) {
zend_class_entry *trait = zend_fetch_class_by_name(ce->trait_names[i].name,
ce->trait_names[i].lc_name, ZEND_FETCH_CLASS_TRAIT);
if (UNEXPECTED(trait == NULL)) {
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
free_alloca(traits_and_interfaces, use_heap);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
return NULL;
}
if (UNEXPECTED(!(trait->ce_flags & ZEND_ACC_TRAIT))) {
zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ZSTR_VAL(ce->name), ZSTR_VAL(trait->name));
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
free_alloca(traits_and_interfaces, use_heap);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
return NULL;
}
for (j = 0; j < i; j++) {
if (traits_and_interfaces[j] == trait) {
/* skip duplications */
trait = NULL;
break;
}
}
traits_and_interfaces[i] = trait;
if (trait) {
UPDATE_IS_CACHEABLE(trait);
}
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
}
}
if (ce->num_interfaces) {
for (i = 0; i < ce->num_interfaces; i++) {
zend_class_entry *iface = zend_fetch_class_by_name(
ce->interface_names[i].name, ce->interface_names[i].lc_name,
ZEND_FETCH_CLASS_INTERFACE |
ZEND_FETCH_CLASS_ALLOW_NEARLY_LINKED | ZEND_FETCH_CLASS_EXCEPTION);
if (!iface) {
check_unrecoverable_load_failure(ce);
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
free_alloca(traits_and_interfaces, use_heap);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
return NULL;
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
traits_and_interfaces[ce->num_traits + i] = iface;
if (iface) {
UPDATE_IS_CACHEABLE(iface);
}
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
}
}
Implement enums RFC: https://wiki.php.net/rfc/enumerations Co-authored-by: Nikita Popov <nikita.ppv@gmail.com> Closes GH-6489.
2020-06-11 05:10:18 +08:00
#ifndef ZEND_WIN32
if (ce->ce_flags & ZEND_ACC_ENUM) {
/* We will add internal methods. */
is_cacheable = false;
}
#endif
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
Perform preloading attempt on copied class It is very hard to determine in advance whether class linking will fail due to missing dependencies in variance checks (#7314 attempts this). This patch takes an alternative approach where we try to perform inheritance on a copy of the class (zend_lazy_class_load) and then restore the original class if inheritance fails. The fatal error in that case is recorded and thrown as a warning later. Closes GH-7319.
2021-07-29 22:50:00 +08:00
bool orig_record_errors = EG(record_errors);
Replay warnings during inheritance (#6928) Since 3e6b447979a2b1f351faf40bee9c6cf7e362d85a it is again possible to have warnings (deprecations) during inheritance, and more such functionality is likely in the future. This is a problem, because such warnings will only be shown on the first request if the opcache inheritance cache is used. This currently causes test failures in --repeat builds. Fix this by uplifting the error recording functionality from opcache to Zend, and then using it to persist a warning trace in the inheritance cache, which can then be used to replay the warnings on subsequent executions.
2021-04-29 22:37:53 +08:00
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
if (ce->ce_flags & ZEND_ACC_IMMUTABLE && is_cacheable) {
if (zend_inheritance_cache_get && zend_inheritance_cache_add) {
zend_class_entry *ret = zend_inheritance_cache_get(ce, parent, traits_and_interfaces);
if (ret) {
if (traits_and_interfaces) {
free_alloca(traits_and_interfaces, use_heap);
}
zv = zend_hash_find_known_hash(CG(class_table), key);
Z_CE_P(zv) = ret;
return ret;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
}
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
/* Make sure warnings (such as deprecations) thrown during inheritance
* will be recorded in the inheritance cache. */
zend_begin_record_errors();
} else {
is_cacheable = 0;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
}
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
proto = ce;
Drop HAS_UNLINKED_USES flag Instead always use the unlinked_uses table, which is already used if opcache is used. Not much point in having a different mechanism for the non-opcache case.
2021-07-29 22:09:23 +08:00
}
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
zend_try {
if (ce->ce_flags & ZEND_ACC_IMMUTABLE) {
/* Lazy class loading */
ce = zend_lazy_class_load(ce);
zv = zend_hash_find_known_hash(CG(class_table), key);
Z_CE_P(zv) = ce;
} else if (ce->ce_flags & ZEND_ACC_FILE_CACHED) {
/* Lazy class loading */
ce = zend_lazy_class_load(ce);
ce->ce_flags &= ~ZEND_ACC_FILE_CACHED;
zv = zend_hash_find_known_hash(CG(class_table), key);
Z_CE_P(zv) = ce;
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
if (CG(unlinked_uses)) {
zend_hash_index_del(CG(unlinked_uses), (zend_long)(zend_uintptr_t) ce);
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
orig_linking_class = CG(current_linking_class);
CG(current_linking_class) = is_cacheable ? ce : NULL;
Implement enums RFC: https://wiki.php.net/rfc/enumerations Co-authored-by: Nikita Popov <nikita.ppv@gmail.com> Closes GH-6489.
2020-06-11 05:10:18 +08:00
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
if (ce->ce_flags & ZEND_ACC_ENUM) {
/* Only register builtin enum methods during inheritance to avoid persisting them in
* opcache. */
zend_enum_register_funcs(ce);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
if (parent) {
if (!(parent->ce_flags & ZEND_ACC_LINKED)) {
add_dependency_obligation(ce, parent);
}
zend_do_inheritance(ce, parent);
}
if (ce->num_traits) {
zend_do_bind_traits(ce, traits_and_interfaces);
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
}
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
if (ce->num_interfaces) {
/* Also copy the parent interfaces here, so we don't need to reallocate later. */
uint32_t num_parent_interfaces = parent ? parent->num_interfaces : 0;
zend_class_entry **interfaces = emalloc(
sizeof(zend_class_entry *) * (ce->num_interfaces + num_parent_interfaces));
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
if (num_parent_interfaces) {
memcpy(interfaces, parent->interfaces,
sizeof(zend_class_entry *) * num_parent_interfaces);
}
memcpy(interfaces + num_parent_interfaces, traits_and_interfaces + ce->num_traits,
sizeof(zend_class_entry *) * ce->num_interfaces);
Implement typed properties RFC: https://wiki.php.net/rfc/typed_properties_v2 This is a squash of PR #3734, which is a squash of PR #3313. Co-authored-by: Bob Weinand <bobwei9@hotmail.com> Co-authored-by: Joe Watkins <krakjoe@php.net> Co-authored-by: Dmitry Stogov <dmitry@zend.com>
2019-01-07 19:28:51 +08:00
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
zend_do_implement_interfaces(ce, interfaces);
} else if (parent && parent->num_interfaces) {
zend_do_inherit_interfaces(ce, parent);
}
if (!(ce->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT))
&& (ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))
) {
zend_verify_abstract_class(ce);
}
if (ce->ce_flags & ZEND_ACC_ENUM) {
zend_verify_enum(ce);
}
/* Normally Stringable is added during compilation. However, if it is imported from a trait,
* we need to explicilty add the interface here. */
if (ce->__tostring && !(ce->ce_flags & ZEND_ACC_TRAIT)
Don't implement Stringable on traits Traits do not support interfaces, so we should not implement Stringable on them. Also check the __toString() return type in the same way other magic methods do, otherwise we would now miss the check in the trait case.
2021-11-05 16:42:58 +08:00
&& !zend_class_implements_interface(ce, zend_ce_stringable)) {
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
ZEND_ASSERT(ce->__tostring->common.fn_flags & ZEND_ACC_TRAIT_CLONE);
ce->ce_flags |= ZEND_ACC_RESOLVED_INTERFACES;
ce->num_interfaces++;
ce->interfaces = perealloc(ce->interfaces,
sizeof(zend_class_entry *) * ce->num_interfaces, ce->type == ZEND_INTERNAL_CLASS);
ce->interfaces[ce->num_interfaces - 1] = zend_ce_stringable;
do_interface_implementation(ce, zend_ce_stringable);
}
zend_build_properties_info_table(ce);
} zend_catch {
/* Do not leak recorded errors to the next linked class. */
if (!orig_record_errors) {
EG(record_errors) = false;
zend_free_recorded_errors();
}
zend_bailout();
} zend_end_try();
Fixed bug #81582 If __toString() comes from a trait, implement Stringable during inheritance.
2021-11-04 18:28:00 +08:00
Perform preloading attempt on copied class It is very hard to determine in advance whether class linking will fail due to missing dependencies in variance checks (#7314 attempts this). This patch takes an alternative approach where we try to perform inheritance on a copy of the class (zend_lazy_class_load) and then restore the original class if inheritance fails. The fatal error in that case is recorded and thrown as a warning later. Closes GH-7319.
2021-07-29 22:50:00 +08:00
EG(record_errors) = orig_record_errors;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
if (!(ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE)) {
ce->ce_flags |= ZEND_ACC_LINKED;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
} else {
ce->ce_flags |= ZEND_ACC_NEARLY_LINKED;
if (CG(current_linking_class)) {
ce->ce_flags |= ZEND_ACC_CACHEABLE;
}
Convert exception during delayed autoload to fatal error Same as with other exceptions during inheritance, convert those thrown during delayed class loading into fatal errors. We can't properly deal with such exceptions, as inheritance cannot be gracefully aborted at this point. Fixes oss-fuzz #39405.
2021-09-29 16:01:05 +08:00
load_delayed_classes(ce);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
if (ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE) {
resolve_delayed_variance_obligations(ce);
}
if (ce->ce_flags & ZEND_ACC_CACHEABLE) {
ce->ce_flags &= ~ZEND_ACC_CACHEABLE;
} else {
CG(current_linking_class) = NULL;
}
}
if (!CG(current_linking_class)) {
is_cacheable = 0;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
CG(current_linking_class) = orig_linking_class;
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
if (is_cacheable) {
HashTable *ht = (HashTable*)ce->inheritance_cache;
zend_class_entry *new_ce;
ce->inheritance_cache = NULL;
new_ce = zend_inheritance_cache_add(ce, proto, parent, traits_and_interfaces, ht);
if (new_ce) {
Remove leading underscore for _zend_hash_find_known_hash (#7260) Convert zend_hash_find_ex(..., 1) to zend_hash_find_known_hash(...) Convert zend_hash_find_ex(..., 0) to zend_hash_find(...) Also add serializable changes to UPGRADING.INTERNALS summary
2021-07-21 07:07:17 +08:00
zv = zend_hash_find_known_hash(CG(class_table), key);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
ce = new_ce;
Z_CE_P(zv) = ce;
}
if (ht) {
zend_hash_destroy(ht);
FREE_HASHTABLE(ht);
Support full variance if autoloading is used Keep track of delayed variance obligations and check them after linking a class is otherwise finished. Obligations may either be unresolved method compatibility (because the necessecary classes aren't available yet) or open parent/interface dependencies. The latter occur because we allow the use of not fully linked classes as parents/interfaces now. An important aspect of the implementation is we do not require classes involved in variance checks to be fully linked in order for the class to be fully linked. Because the involved types do have to exist in the class table (as partially linked classes) and we do check these for correct variance, we have the guarantee that either those classes will successfully link lateron or generate an error, but there is no way to actually use them until that point and as such no possibility of violating the variance contract. This is important because it ensures that a class declaration always either errors or will produce an immediately usable class afterwards -- there are no cases where the finalization of the class declaration has to be delayed until a later time, as earlier variants of this patch did. Because variance checks deal with classes in various stages of linking, we need to use a special instanceof implementation that supports this, and also introduce finer-grained flags that tell us which parts have been linked already and which haven't. Class autoloading for variance checks is delayed into a separate stage after the class is otherwise linked and before delayed variance obligations are processed. This separation is needed to handle cases like A extends B extends C, where B is the autoload root, but C is required to check variance. This could end up loading C while the class structure of B is in an inconsistent state.
2019-05-27 17:39:56 +08:00
}
}
Allow throwing exception while loading parent class This is a fix for symfony/symfony#32995. The behavior is: * Throwing exception when loading parent/interface is allowed (and we will also throw one if the class is simply not found). * If this happens, the bucket key for the class is reset, so it's possibly to try registering the same class again. * However, if the class has already been used due to a variance obligation, the exception is upgraded to a fatal error, as we cannot safely unregister the class stub anymore.
2019-09-11 21:31:04 +08:00
Perform preloading attempt on copied class It is very hard to determine in advance whether class linking will fail due to missing dependencies in variance checks (#7314 attempts this). This patch takes an alternative approach where we try to perform inheritance on a copy of the class (zend_lazy_class_load) and then restore the original class if inheritance fails. The fatal error in that case is recorded and thrown as a warning later. Closes GH-7319.
2021-07-29 22:50:00 +08:00
if (!orig_record_errors) {
zend_free_recorded_errors();
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
if (traits_and_interfaces) {
Inheritance cache optimization
2021-03-11 18:42:35 +08:00
free_alloca(traits_and_interfaces, use_heap);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
}
Fast Class Cache This is generalization of idea, that was previously usesd for caching resolution of class_entries in zend_type. Now very similar mechanizm is used for general zend_string into zend_class_entry resolution. Interned zend_string with IS_STR_CLASS_NAME_MAP_PTR GC_FLAG uses its refcount to adress corresponding zend_class_entry cache slot. The refcount keeps an offset to this slot from CG(map_ptr_base). Flag may be checked by ZSTR_HAS_CE_CACHE(str), cache slot may be read by ZSTR_GET_CE_CACHE(str) and set by ZSTR_SET_CE_CACHE(str, ce).
2021-04-09 04:37:40 +08:00
if (ZSTR_HAS_CE_CACHE(ce->name)) {
ZSTR_SET_CE_CACHE(ce->name, ce);
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
return ce;
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
/* }}} */
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
/* Check whether early binding is prevented due to unresolved types in inheritance checks. */
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
static inheritance_status zend_can_early_bind(zend_class_entry *ce, zend_class_entry *parent_ce) /* {{{ */
{
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
zend_string *key;
zend_function *parent_func;
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
zend_property_info *parent_info;
Handle both WARNING and UNRESOLVED during early binding We would previously early exit on the WARNING, and miss the later UNRESOLVED.
2021-07-15 21:23:08 +08:00
inheritance_status overall_status = INHERITANCE_SUCCESS;
Prevent useless hash lookups
2019-06-25 17:41:06 +08:00
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&parent_ce->function_table, key, parent_func) {
Remove leading underscore for _zend_hash_find_known_hash (#7260) Convert zend_hash_find_ex(..., 1) to zend_hash_find_known_hash(...) Convert zend_hash_find_ex(..., 0) to zend_hash_find(...) Also add serializable changes to UPGRADING.INTERNALS summary
2021-07-21 07:07:17 +08:00
zval *zv = zend_hash_find_known_hash(&ce->function_table, key);
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (zv) {
zend_function *child_func = Z_FUNC_P(zv);
inheritance_status status =
Check abstract method signatures coming from traits RFC: https://wiki.php.net/rfc/abstract_trait_method_validation Closes GH-5068.
2020-01-09 22:04:33 +08:00
do_inheritance_check_on_method_ex(
Fix bug #80055 We need to perform trait scope fixup for both methods involved in the inheritance check. For that purpose we already need to thread through a separate fn scope through the entire inheritance checking machinery.
2020-10-15 18:46:07 +08:00
child_func, child_func->common.scope,
parent_func, parent_func->common.scope,
ce, NULL, /* check_visibility */ 1, 1, 0);
Handle both WARNING and UNRESOLVED during early binding We would previously early exit on the WARNING, and miss the later UNRESOLVED.
2021-07-15 21:23:08 +08:00
if (UNEXPECTED(status == INHERITANCE_WARNING)) {
overall_status = INHERITANCE_WARNING;
} else if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
Merge branch 'PHP-7.4' * PHP-7.4: Avoid double checks on early binding
2019-06-27 07:25:57 +08:00
return status;
Fixed variance check for abstract constructor during erlay binding
2019-06-25 22:43:46 +08:00
}
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
} ZEND_HASH_FOREACH_END();
Prevent useless hash lookups
2019-06-25 17:41:06 +08:00
Use more compact representation for packed arrays. - for packed arrays we store just an array of zvals without keys. - the elements of packed array are accessible throuf as ht->arPacked[i] instead of ht->arData[i] - in addition to general ZEND_HASH_FOREACH_* macros, we introduced similar familied for packed (ZEND_HASH_PACKED_FORECH_*) and real hashes (ZEND_HASH_MAP_FOREACH_*) - introduced an additional family of macros to access elements of array (packed or real hashes) ZEND_ARRAY_ELEMET_SIZE, ZEND_ARRAY_ELEMET_EX, ZEND_ARRAY_ELEMET, ZEND_ARRAY_NEXT_ELEMENT, ZEND_ARRAY_PREV_ELEMENT - zend_hash_minmax() prototype was changed to compare only values Because of smaller data set, this patch may show performance improvement on some apps and benchmarks that use packed arrays. (~1% on PHP-Parser) TODO: - sapi/phpdbg needs special support for packed arrays (WATCH_ON_BUCKET). - zend_hash_sort_ex() may require converting packed arrays to hash.
2021-11-03 20:18:26 +08:00
ZEND_HASH_MAP_FOREACH_STR_KEY_PTR(&parent_ce->properties_info, key, parent_info) {
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
zval *zv;
if ((parent_info->flags & ZEND_ACC_PRIVATE) || !ZEND_TYPE_IS_SET(parent_info->type)) {
continue;
}
Remove leading underscore for _zend_hash_find_known_hash (#7260) Convert zend_hash_find_ex(..., 1) to zend_hash_find_known_hash(...) Convert zend_hash_find_ex(..., 0) to zend_hash_find(...) Also add serializable changes to UPGRADING.INTERNALS summary
2021-07-21 07:07:17 +08:00
zv = zend_hash_find_known_hash(&ce->properties_info, key);
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
if (zv) {
zend_property_info *child_info = Z_PTR_P(zv);
if (ZEND_TYPE_IS_SET(child_info->type)) {
inheritance_status status = property_types_compatible(parent_info, child_info);
Handle both WARNING and UNRESOLVED during early binding We would previously early exit on the WARNING, and miss the later UNRESOLVED.
2021-07-15 21:23:08 +08:00
ZEND_ASSERT(status != INHERITANCE_WARNING);
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
if (UNEXPECTED(status != INHERITANCE_SUCCESS)) {
Merge branch 'PHP-7.4' * PHP-7.4: Integrate property types with variance system
2019-10-17 19:42:47 +08:00
return status;
Integrate property types with variance system Property types are invariant, but may still have to load classes in order to check for class aliases. This class loading should follow the same rules as all other variance checks, rather than just loading unconditionally. This change integrates property type invariance checks into the variance system as a new obligation type, and prevent early binding if the type check cannot be performed.
2019-10-17 19:01:02 +08:00
}
}
}
} ZEND_HASH_FOREACH_END();
Handle both WARNING and UNRESOLVED during early binding We would previously early exit on the WARNING, and miss the later UNRESOLVED.
2021-07-15 21:23:08 +08:00
return overall_status;
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
/* }}} */
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
Extract early binding registration code This is the same for the cached and uncached cases and will make GH-7311 a bit simpler.
2021-07-28 17:18:26 +08:00
static zend_always_inline bool register_early_bound_ce(zval *delayed_early_binding, zend_string *lcname, zend_class_entry *ce) {
if (delayed_early_binding) {
Preload unlinked classes, remove preload autoload (#7311) Currently, classes that can't be linked get moved back into the original script and are not preloaded. As such classes may be referenced from functions that did get preloaded, there is a preload autoload mechanism to load them at runtime. Since PHP 8.1, we can safely preload unlinked classes, which will then go through usual lazy loading. This means that we no longer need the preload autoload mechanism. However, we need to be careful not to modify any hash table buckets in-place, and should create new buckets for lazy loaded classes.
2021-07-28 20:27:58 +08:00
if (EXPECTED(!(ce->ce_flags & ZEND_ACC_PRELOADED))) {
if (zend_hash_set_bucket_key(EG(class_table), (Bucket *)delayed_early_binding, lcname) != NULL) {
Z_CE_P(delayed_early_binding) = ce;
return true;
}
} else {
/* If preloading is used, don't replace the existing bucket, add a new one. */
if (zend_hash_add_ptr(EG(class_table), lcname, ce) != NULL) {
return true;
}
Extract early binding registration code This is the same for the cached and uncached cases and will make GH-7311 a bit simpler.
2021-07-28 17:18:26 +08:00
}
Preload unlinked classes, remove preload autoload (#7311) Currently, classes that can't be linked get moved back into the original script and are not preloaded. As such classes may be referenced from functions that did get preloaded, there is a preload autoload mechanism to load them at runtime. Since PHP 8.1, we can safely preload unlinked classes, which will then go through usual lazy loading. This means that we no longer need the preload autoload mechanism. However, we need to be careful not to modify any hash table buckets in-place, and should create new buckets for lazy loaded classes.
2021-07-28 20:27:58 +08:00
zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare %s %s, because the name is already in use", zend_get_object_type(ce), ZSTR_VAL(ce->name));
return false;
Extract early binding registration code This is the same for the cached and uncached cases and will make GH-7311 a bit simpler.
2021-07-28 17:18:26 +08:00
}
Add an API to observe functions and classes being linked To observe when the functions and classes start being officially available to the user Signed-off-by: Bob Weinand <bobwei9@hotmail.com>
2022-07-11 22:19:26 +08:00
if (zend_hash_add_ptr(CG(class_table), lcname, ce) != NULL) {
return true;
}
return false;
Extract early binding registration code This is the same for the cached and uncached cases and will make GH-7311 a bit simpler.
2021-07-28 17:18:26 +08:00
}
Fix delayed early binding with optimization It's possible for delayed early binding opcodes to get optimized away if they are "unreachable". However, we still need to attempt early binding for them. (In some cases we also corrupt the early binding list outright during optimization, which is how I got here.) Fix this by storing information about delayed early binding independently of DECLARE_CLASS_DELAYED opcodes, so early binding is performed even after the opcode has been dropped.
2021-09-27 18:21:40 +08:00
ZEND_API zend_class_entry *zend_try_early_bind(zend_class_entry *ce, zend_class_entry *parent_ce, zend_string *lcname, zval *delayed_early_binding) /* {{{ */
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
{
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
inheritance_status status;
zend_class_entry *proto = NULL;
zend_class_entry *orig_linking_class;
uint32_t is_cacheable = ce->ce_flags & ZEND_ACC_IMMUTABLE;
UPDATE_IS_CACHEABLE(parent_ce);
if (is_cacheable) {
if (zend_inheritance_cache_get && zend_inheritance_cache_add) {
zend_class_entry *ret = zend_inheritance_cache_get(ce, parent_ce, NULL);
if (ret) {
Extract early binding registration code This is the same for the cached and uncached cases and will make GH-7311 a bit simpler.
2021-07-28 17:18:26 +08:00
if (UNEXPECTED(!register_early_bound_ce(delayed_early_binding, lcname, ret))) {
return NULL;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
}
Fix observing inherited internal functions Fixes GH-9871
2022-11-02 22:28:53 +08:00
zend_observer_class_linked_notify(ret, lcname);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
return ret;
}
} else {
is_cacheable = 0;
}
proto = ce;
}
Reorder conditions to minimize number of checks on fast path
2019-06-26 06:00:31 +08:00
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
orig_linking_class = CG(current_linking_class);
CG(current_linking_class) = NULL;
status = zend_can_early_bind(ce, parent_ce);
CG(current_linking_class) = orig_linking_class;
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
if (EXPECTED(status != INHERITANCE_UNRESOLVED)) {
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
if (ce->ce_flags & ZEND_ACC_IMMUTABLE) {
/* Lazy class loading */
ce = zend_lazy_class_load(ce);
} else if (ce->ce_flags & ZEND_ACC_FILE_CACHED) {
/* Lazy class loading */
ce = zend_lazy_class_load(ce);
ce->ce_flags &= ~ZEND_ACC_FILE_CACHED;
}
Extract early binding registration code This is the same for the cached and uncached cases and will make GH-7311 a bit simpler.
2021-07-28 17:18:26 +08:00
if (UNEXPECTED(!register_early_bound_ce(delayed_early_binding, lcname, ce))) {
return NULL;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
orig_linking_class = CG(current_linking_class);
CG(current_linking_class) = is_cacheable ? ce : NULL;
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
zend_try{
if (is_cacheable) {
zend_begin_record_errors();
}
Record warnings during early binding These should also get replayed when the class is loaded from opcache.
2021-05-17 16:18:26 +08:00
Clear recorded errors before executing shutdown functions Recorded errors may be attached to the wrong cached script when a fatal error occurs during recording. This happens because the fatal error will cause a bailout, which may prevent the recorded errors from being freed. If an other script is compiled after bailout, or if a class is linked after bailout, the recorded errors will be attached to it. This change fixes this by freeing recorded errors before executing shutdown functions. Fixes GH-8063
2022-04-03 19:16:33 +08:00
zend_do_inheritance_ex(ce, parent_ce, status == INHERITANCE_SUCCESS);
if (parent_ce && parent_ce->num_interfaces) {
zend_do_inherit_interfaces(ce, parent_ce);
}
zend_build_properties_info_table(ce);
if ((ce->ce_flags & (ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_INTERFACE|ZEND_ACC_TRAIT|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) == ZEND_ACC_IMPLICIT_ABSTRACT_CLASS) {
zend_verify_abstract_class(ce);
}
ZEND_ASSERT(!(ce->ce_flags & ZEND_ACC_UNRESOLVED_VARIANCE));
ce->ce_flags |= ZEND_ACC_LINKED;
CG(current_linking_class) = orig_linking_class;
} zend_catch {
EG(record_errors) = false;
zend_free_recorded_errors();
zend_bailout();
} zend_end_try();
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
Record warnings during early binding These should also get replayed when the class is loaded from opcache.
2021-05-17 16:18:26 +08:00
EG(record_errors) = false;
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
if (is_cacheable) {
HashTable *ht = (HashTable*)ce->inheritance_cache;
zend_class_entry *new_ce;
ce->inheritance_cache = NULL;
new_ce = zend_inheritance_cache_add(ce, proto, parent_ce, NULL, ht);
if (new_ce) {
Remove leading underscore for _zend_hash_find_known_hash (#7260) Convert zend_hash_find_ex(..., 1) to zend_hash_find_known_hash(...) Convert zend_hash_find_ex(..., 0) to zend_hash_find(...) Also add serializable changes to UPGRADING.INTERNALS summary
2021-07-21 07:07:17 +08:00
zval *zv = zend_hash_find_known_hash(CG(class_table), lcname);
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
ce = new_ce;
Z_CE_P(zv) = ce;
}
if (ht) {
zend_hash_destroy(ht);
FREE_HASHTABLE(ht);
}
}
Fast Class Cache This is generalization of idea, that was previously usesd for caching resolution of class_entries in zend_type. Now very similar mechanizm is used for general zend_string into zend_class_entry resolution. Interned zend_string with IS_STR_CLASS_NAME_MAP_PTR GC_FLAG uses its refcount to adress corresponding zend_class_entry cache slot. The refcount keeps an offset to this slot from CG(map_ptr_base). Flag may be checked by ZSTR_HAS_CE_CACHE(str), cache slot may be read by ZSTR_GET_CE_CACHE(str) and set by ZSTR_SET_CE_CACHE(str, ce).
2021-04-09 04:37:40 +08:00
if (ZSTR_HAS_CE_CACHE(ce->name)) {
ZSTR_SET_CE_CACHE(ce->name, ce);
}
Fix observing inherited internal functions Fixes GH-9871
2022-11-02 22:28:53 +08:00
zend_observer_class_linked_notify(ce, lcname);
Fast Class Cache This is generalization of idea, that was previously usesd for caching resolution of class_entries in zend_type. Now very similar mechanizm is used for general zend_string into zend_class_entry resolution. Interned zend_string with IS_STR_CLASS_NAME_MAP_PTR GC_FLAG uses its refcount to adress corresponding zend_class_entry cache slot. The refcount keeps an offset to this slot from CG(map_ptr_base). Flag may be checked by ZSTR_HAS_CE_CACHE(str), cache slot may be read by ZSTR_GET_CE_CACHE(str) and set by ZSTR_SET_CE_CACHE(str, ce).
2021-04-09 04:37:40 +08:00
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
return ce;
Avoid double checks on early binding
2019-06-27 07:13:06 +08:00
}
Added Inheritance Cache. This is a new transparent technology that eliminates overhead of PHP class inheritance. PHP classes are compiled and cached (by opcahce) separately, however their "linking" was done at run-time - on each request. The process of "linking" may involve a number of compatibility checks and borrowing methods/properties/constants form parent and traits. This takes significant time, but the result is the same on each request. Inheritance Cache performs "linking" for unique set of all the depending classes (parent, interfaces, traits, property types, method types involved into compatibility checks) once and stores result in opcache shared memory. As a part of the this patch, I removed limitations for immutable classes (unresolved constants, typed properties and covariant type checks). So now all classes stored in opcache are "immutable". They may be lazily loaded into process memory, if necessary, but this usually occurs just once (on first linking). The patch shows 8% improvement on Symphony "Hello World" app.
2021-02-10 03:53:57 +08:00
return NULL;
Avoid early-binding on unresolved types Fixes bug #76451, and more importantly lays necessary groundwork for covariant/contravariant types. Bug #76451 is just an edge case, but once covariance is introduced this will become a common problem instead.
2019-05-09 16:41:06 +08:00
}
Move zend_verify_abstract_class() into zend_inheritance.c
2018-08-27 17:56:17 +08:00
/* }}} */
Reference in New Issue Copy Permalink