Skip to content

Commit 40a7b1c

Browse files
bwoebibwoebi
committed
Add support for internal enums via stub generation
This uses persistently malloc()'ed objects, which get duplicated to an request-unique object. Those request-unique objects are supposed to be immutable for the lifetime of the request, i.e. they can be just efree()'d without issues.
1 parent 7bc0dd2 commit 40a7b1c

17 files changed

+562
-42
lines changed

‎Zend/Optimizer/pass1.c

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -274,6 +274,8 @@ void zend_optimizer_pass1(zend_op_array *op_array, zend_optimizer_ctx *ctx)
274274
|| Z_TYPE(t) == IS_CONSTANT_AST) {
275275
break;
276276
}
277+
} else if (Z_TYPE_P(c) == IS_OBJECT) {
278+
break;
277279
} else {
278280
ZVAL_COPY_OR_DUP(&t, c);
279281
}

‎Zend/tests/enum/internal-enum-persistent.phpt

Lines changed: 48 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,48 @@
1+
--TEST--
2+
Internal enums are persistent
3+
--EXTENSIONS--
4+
zend_test
5+
--FILE--
6+
<?php
7+
8+
var_dump(ZendTestStringBacked::FIRST);
9+
var_dump(ZendTestStringBacked::FIRST == ZendTestStringBacked::getFirst());
10+
var_dump(ZendTestStringBacked::FIRST != ZendTestUnbacked::FIRST);
11+
var_dump(ZendTestStringBacked::FIRST->value);
12+
var_dump(ZendTestIntBacked::FIRST->value);
13+
14+
var_dump(ZendTestStringBacked::FIRST instanceof UnitEnum, ZendTestStringBacked::FIRST instanceof BackedEnum);
15+
var_dump(ZendTestUnbacked::FIRST instanceof UnitEnum, ZendTestUnbacked::FIRST instanceof BackedEnum);
16+
17+
var_dump(ZendTestUnbacked::cases());
18+
var_dump(ZendTestStringBacked::cases());
19+
var_dump(ZendTestIntBacked::from(42));
20+
var_dump(ZendTestStringBacked::tryFrom("foo"));
21+
var_dump(ZendTestStringBacked::tryFrom("a"));
22+
23+
?>
24+
--EXPECT--
25+
enum(ZendTestStringBacked::FIRST)
26+
bool(true)
27+
bool(true)
28+
string(1) "a"
29+
int(42)
30+
bool(true)
31+
bool(true)
32+
bool(true)
33+
bool(false)
34+
array(2) {
35+
[0]=>
36+
enum(ZendTestUnbacked::FIRST)
37+
[1]=>
38+
enum(ZendTestUnbacked::SECOND)
39+
}
40+
array(2) {
41+
[0]=>
42+
enum(ZendTestStringBacked::FIRST)
43+
[1]=>
44+
enum(ZendTestStringBacked::SECOND)
45+
}
46+
enum(ZendTestIntBacked::FIRST)
47+
NULL
48+
enum(ZendTestStringBacked::FIRST)

‎Zend/zend_API.h

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -40,6 +40,8 @@ typedef struct _zend_function_entry {
4040
uint32_t flags;
4141
} zend_function_entry;
4242

43+
#include "zend_enum.h"
44+
4345
typedef struct _zend_fcall_info {
4446
size_t size;
4547
zval function_name;

‎Zend/zend_enum.c

Lines changed: 139 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -19,8 +19,10 @@
1919
#include "zend.h"
2020
#include "zend_API.h"
2121
#include "zend_compile.h"
22-
#include "zend_enum_arginfo.h"
2322
#include "zend_interfaces.h"
23+
#include "zend_inheritance.h"
24+
#include "zend_constants.h"
25+
#include "zend_enum_arginfo.h"
2426

2527
#define ZEND_ENUM_PROPERTY_ERROR() \
2628
zend_throw_error(NULL, "Enum properties are immutable")
@@ -37,19 +39,22 @@ ZEND_API zend_class_entry *zend_ce_backed_enum;
3739

3840
static zend_object_handlers enum_handlers;
3941

40-
zend_object *zend_enum_new(zval *result, zend_class_entry *ce, zend_string *case_name, zval *backing_value_zv)
42+
static void enum_obj_init(zend_object *obj, zend_string *case_name, zval *backing_value_zv)
4143
{
42-
zend_object *zobj = zend_objects_new(ce);
43-
ZVAL_OBJ(result, zobj);
44-
45-
ZVAL_STR_COPY(OBJ_PROP_NUM(zobj, 0), case_name);
44+
ZVAL_STR_COPY(OBJ_PROP_NUM(obj, 0), case_name);
4645
if (backing_value_zv != NULL) {
47-
ZVAL_COPY(OBJ_PROP_NUM(zobj, 1), backing_value_zv);
46+
ZVAL_COPY(OBJ_PROP_NUM(obj, 1), backing_value_zv);
4847
}
4948

50-
zobj->handlers = &enum_handlers;
49+
obj->handlers = &enum_handlers;
50+
}
5151

52-
return zobj;
52+
zend_object *zend_enum_new(zval *result, zend_class_entry *ce, zend_string *case_name, zval *backing_value_zv)
53+
{
54+
zend_object *obj = zend_objects_new(ce);
55+
ZVAL_OBJ(result, obj);
56+
enum_obj_init(obj, case_name, backing_value_zv);
57+
return obj;
5358
}
5459

5560
static void zend_verify_enum_properties(zend_class_entry *ce)
@@ -371,3 +376,128 @@ void zend_enum_register_props(zend_class_entry *ce)
371376
zend_declare_typed_property(ce, ZSTR_KNOWN(ZEND_STR_VALUE), &value_default_value, ZEND_ACC_PUBLIC, NULL, value_type);
372377
}
373378
}
379+
380+
static const zend_function_entry simple_internal_methods[] = {
381+
ZEND_NAMED_ME(cases, zend_enum_cases_func, arginfo_class_UnitEnum_cases, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
382+
ZEND_FE_END
383+
};
384+
385+
static const zend_function_entry backed_internal_methods[] = {
386+
ZEND_NAMED_ME(from, zend_enum_from_func, arginfo_class_BackedEnum_from, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
387+
ZEND_NAMED_ME(tryFrom, zend_enum_try_from_func, arginfo_class_BackedEnum_tryFrom, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
388+
ZEND_FE_END
389+
};
390+
391+
ZEND_API zend_class_entry *zend_register_internal_enum(const char *name)
392+
{
393+
return zend_register_internal_backed_enum_ex(name, IS_UNDEF, NULL);
394+
}
395+
396+
ZEND_API zend_class_entry *zend_register_internal_enum_ex(const char *name, const zend_function_entry *functions)
397+
{
398+
return zend_register_internal_backed_enum_ex(name, IS_UNDEF, functions);
399+
}
400+
401+
ZEND_API zend_class_entry *zend_register_internal_backed_enum(const char *name, uint32_t backing_type)
402+
{
403+
return zend_register_internal_backed_enum_ex(name, backing_type, NULL);
404+
}
405+
406+
ZEND_API zend_class_entry *zend_register_internal_backed_enum_ex(const char *name, uint32_t backing_type, const zend_function_entry *functions)
407+
{
408+
ZEND_ASSERT(backing_type == IS_UNDEF || backing_type == IS_STRING || backing_type == IS_LONG);
409+
410+
zend_class_entry ce_val, *ce;
411+
INIT_CLASS_ENTRY_EX(ce_val, name, strlen(name), functions);
412+
ce = zend_register_internal_class(&ce_val);
413+
414+
ce->ce_flags |= ZEND_ACC_ENUM;
415+
ce->enum_backing_type = backing_type;
416+
ce->backed_enum_table = malloc(sizeof(HashTable));
417+
zend_hash_init(ce->backed_enum_table, 0, NULL, ZVAL_PTR_DTOR, 1);
418+
zend_enum_register_props(ce);
419+
420+
zend_register_functions(ce, simple_internal_methods, &ce->function_table, EG(current_module)->type);
421+
zend_do_implement_interface(ce, zend_ce_unit_enum);
422+
if (backing_type != IS_UNDEF) {
423+
zend_register_functions(ce, backed_internal_methods, &ce->function_table, EG(current_module)->type);
424+
zend_do_implement_interface(ce, zend_ce_backed_enum);
425+
}
426+
427+
return ce;
428+
}
429+
430+
static zend_object *add_internal_enum_case(zend_class_entry *ce, zend_string *name, zval *value)
431+
{
432+
zend_object *case_obj = zend_objects_new_persistent(ce);
433+
enum_obj_init(case_obj, name, value);
434+
435+
zval casezv;
436+
ZVAL_OBJ(&casezv, case_obj);
437+
zend_class_constant *c = zend_declare_class_constant_ex(ce, name, &casezv, ZEND_ACC_PUBLIC, NULL);
438+
ZEND_CLASS_CONST_FLAGS(c) |= ZEND_CLASS_CONST_IS_CASE;
439+
440+
zend_string_release(name);
441+
if (value) {
442+
zval_internal_ptr_dtor(value);
443+
}
444+
445+
return case_obj;
446+
}
447+
448+
ZEND_API zend_object *zend_add_enum_case_ex(zend_class_entry *ce, zend_string *name)
449+
{
450+
ZEND_ASSERT(ce->enum_backing_type == IS_UNDEF);
451+
452+
name = zend_new_interned_string(name);
453+
454+
zend_object *case_obj = add_internal_enum_case(ce, name, NULL);
455+
456+
zend_string_release(name);
457+
458+
return case_obj;
459+
}
460+
461+
ZEND_API zend_object *zend_add_enum_case_long_ex(zend_class_entry *ce, zend_string *name, zend_long value)
462+
{
463+
ZEND_ASSERT(ce->enum_backing_type == IS_LONG);
464+
465+
name = zend_new_interned_string(name);
466+
467+
zval namezv;
468+
ZVAL_STR_COPY(&namezv, name);
469+
if (!zend_hash_index_add(ce->backed_enum_table, value, &namezv)) {
470+
ZEND_ASSERT(0 && "Cannot add two enum values with the same backing value");
471+
}
472+
473+
zval zv;
474+
ZVAL_LONG(&zv, value);
475+
zend_object *case_obj = add_internal_enum_case(ce, name, &zv);
476+
477+
zend_string_release(name);
478+
479+
return case_obj;
480+
}
481+
482+
ZEND_API zend_object *zend_add_enum_case_str_ex(zend_class_entry *ce, zend_string *name, zend_string *str)
483+
{
484+
ZEND_ASSERT(ce->enum_backing_type == IS_STRING);
485+
486+
name = zend_new_interned_string(name);
487+
str = zend_new_interned_string(str);
488+
489+
zval namezv;
490+
ZVAL_STR_COPY(&namezv, name);
491+
if (!zend_hash_add(ce->backed_enum_table, str, &namezv)) {
492+
ZEND_ASSERT(0 && "Cannot add two enum values with the same backing value");
493+
}
494+
495+
zval zv;
496+
ZVAL_STR(&zv, str);
497+
zend_object *case_obj = add_internal_enum_case(ce, name, &zv);
498+
499+
zend_string_release(name);
500+
zend_string_release(str);
501+
502+
return case_obj;
503+
}

‎Zend/zend_enum.h

Lines changed: 17 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020
#define ZEND_ENUM_H
2121

2222
#include "zend.h"
23+
#include "zend_API.h"
2324
#include "zend_types.h"
2425

2526
BEGIN_EXTERN_C()
@@ -47,6 +48,22 @@ static zend_always_inline zval *zend_enum_fetch_case_value(zend_object *zobj)
4748
return OBJ_PROP_NUM(zobj, 1);
4849
}
4950

51+
ZEND_API zend_class_entry *zend_register_internal_enum(const char *name);
52+
ZEND_API zend_class_entry *zend_register_internal_enum_ex(const char *name, const zend_function_entry *functions);
53+
ZEND_API zend_class_entry *zend_register_internal_backed_enum(const char *name, uint32_t backing_type);
54+
ZEND_API zend_class_entry *zend_register_internal_backed_enum_ex(const char *name, uint32_t backing_type, const zend_function_entry *functions);
55+
56+
#define zend_add_enum_case(ce, name) zend_add_enum_case_ex(ce, zend_string_init(name, sizeof(name) - 1, 1))
57+
ZEND_API zend_object *zend_add_enum_case_ex(zend_class_entry *ce, zend_string *name);
58+
59+
#define zend_add_enum_case_long(ce, name, long) zend_add_enum_case_long_ex(ce, zend_string_init(name, sizeof(name) - 1, 1), long)
60+
ZEND_API zend_object *zend_add_enum_case_long_ex(zend_class_entry *ce, zend_string *name, zend_long value);
61+
62+
#define zend_add_enum_case_string(ce, name, str) zend_add_enum_case_string_ex(ce, zend_string_init(name, sizeof(name) - 1, 1), str)
63+
#define zend_add_enum_case_str(ce, name, str) zend_add_enum_case_str_ex(ce, zend_string_init(name, sizeof(name) - 1, 1), str)
64+
#define zend_add_enum_case_string_ex(ce, name, str) zend_add_enum_case_str_ex(ce, name, zend_string_init(str, sizeof(str) - 1, 1))
65+
ZEND_API zend_object *zend_add_enum_case_str_ex(zend_class_entry *ce, zend_string *name, zend_string *str);
66+
5067
END_EXTERN_C()
5168

5269
#endif /* ZEND_ENUM_H */

‎Zend/zend_execute_API.c

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -185,6 +185,7 @@ void init_executor(void) /* {{{ */
185185
EG(persistent_constants_count) = EG(zend_constants)->nNumUsed;
186186
EG(persistent_functions_count) = EG(function_table)->nNumUsed;
187187
EG(persistent_classes_count) = EG(class_table)->nNumUsed;
188+
EG(persistent_objects) = (zend_object *) ecalloc(sizeof(zend_object), zend_objects_persistent_handle_counter);
188189

189190
EG(get_gc_buffer).start = EG(get_gc_buffer).end = EG(get_gc_buffer).cur = NULL;
190191

@@ -431,6 +432,7 @@ void shutdown_executor(void) /* {{{ */
431432
zend_stack_destroy(&EG(user_error_handlers_error_reporting));
432433
zend_stack_destroy(&EG(user_error_handlers));
433434
zend_stack_destroy(&EG(user_exception_handlers));
435+
efree(EG(persistent_objects));
434436
zend_objects_store_destroy(&EG(objects_store));
435437
if (EG(in_autoload)) {
436438
zend_hash_destroy(EG(in_autoload));

‎Zend/zend_gc.c

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -79,13 +79,13 @@
7979
#endif
8080

8181
/* GC_INFO layout */
82-
#define GC_ADDRESS 0x0fffffu
83-
#define GC_COLOR 0x300000u
82+
#define GC_ADDRESS 0x07ffffu
83+
#define GC_COLOR 0x180000u
8484

8585
#define GC_BLACK 0x000000u /* must be zero */
86-
#define GC_WHITE 0x100000u
87-
#define GC_GREY 0x200000u
88-
#define GC_PURPLE 0x300000u
86+
#define GC_WHITE 0x080000u
87+
#define GC_GREY 0x100000u
88+
#define GC_PURPLE 0x180000u
8989

9090
/* Debug tracing */
9191
#if ZEND_GC_DEBUG > 1

‎Zend/zend_globals.h

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -181,6 +181,7 @@ struct _zend_executor_globals {
181181
uint32_t persistent_constants_count;
182182
uint32_t persistent_functions_count;
183183
uint32_t persistent_classes_count;
184+
zend_object *persistent_objects;
184185

185186
HashTable *in_autoload;
186187
bool full_tables_cleanup;

‎Zend/zend_objects.c

Lines changed: 32 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -26,12 +26,19 @@
2626
#include "zend_exceptions.h"
2727
#include "zend_weakrefs.h"
2828

29-
static zend_always_inline void _zend_object_std_init(zend_object *object, zend_class_entry *ce)
29+
ZEND_API uint32_t zend_objects_persistent_handle_counter = 0;
30+
31+
static zend_always_inline void _zend_object_minimal_init(zend_object *object, zend_class_entry *ce)
3032
{
3133
GC_SET_REFCOUNT(object, 1);
3234
GC_TYPE_INFO(object) = GC_OBJECT;
3335
object->ce = ce;
3436
object->properties = NULL;
37+
}
38+
39+
static zend_always_inline void _zend_object_std_init(zend_object *object, zend_class_entry *ce)
40+
{
41+
_zend_object_minimal_init(object, ce);
3542
zend_objects_store_put(object);
3643
if (UNEXPECTED(ce->ce_flags & ZEND_ACC_USE_GUARDS)) {
3744
ZVAL_UNDEF(object->properties_table + object->ce->default_properties_count);
@@ -282,3 +289,27 @@ ZEND_API zend_object *zend_objects_clone_obj(zend_object *old_object)
282289

283290
return new_object;
284291
}
292+
293+
ZEND_API zend_object *zend_objects_new_persistent(zend_class_entry *ce)
294+
{
295+
size_t alloc_size = sizeof(zend_object) + zend_object_properties_size(ce);
296+
zend_object *obj = malloc(alloc_size);
297+
_zend_object_minimal_init(obj, ce);
298+
GC_TYPE_INFO(obj) |= IS_OBJ_PERSISTENT << GC_FLAGS_SHIFT;
299+
obj->handle = zend_objects_persistent_handle_counter;
300+
zend_objects_persistent_handle_counter += (alloc_size - 1) / sizeof(zend_object) + 1;
301+
return obj;
302+
}
303+
304+
ZEND_API zend_object* ZEND_FASTCALL zend_objects_persistent_copy(zend_object *object)
305+
{
306+
ZEND_ASSERT(GC_FLAGS(object) & IS_OBJ_PERSISTENT);
307+
308+
zend_object *target = EG(persistent_objects) + object->handle;
309+
if (UNEXPECTED(GC_REFCOUNT(target) == 0)) { // non-initialized
310+
memcpy(target, object, sizeof(zend_object) + zend_object_properties_size(object->ce));
311+
}
312+
GC_TYPE_INFO(target) &= ~(IS_OBJ_PERSISTENT << GC_FLAGS_SHIFT);
313+
GC_ADDREF(target);
314+
return target;
315+
}

‎Zend/zend_objects.h

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -23,10 +23,15 @@
2323
#include "zend.h"
2424

2525
BEGIN_EXTERN_C()
26+
extern ZEND_API uint32_t zend_objects_persistent_handle_counter;
27+
2628
ZEND_API void ZEND_FASTCALL zend_object_std_init(zend_object *object, zend_class_entry *ce);
2729
ZEND_API zend_object* ZEND_FASTCALL zend_objects_new(zend_class_entry *ce);
2830
ZEND_API void ZEND_FASTCALL zend_objects_clone_members(zend_object *new_object, zend_object *old_object);
2931

32+
ZEND_API zend_object *zend_objects_new_persistent(zend_class_entry *ce);
33+
ZEND_API zend_object* ZEND_FASTCALL zend_objects_persistent_copy(zend_object *object);
34+
3035
ZEND_API void zend_object_std_dtor(zend_object *object);
3136
ZEND_API void zend_objects_destroy_object(zend_object *object);
3237
ZEND_API zend_object *zend_objects_clone_obj(zend_object *object);

‎Zend/zend_opcode.c

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -439,6 +439,9 @@ ZEND_API void destroy_zend_class(zval *zv)
439439
}
440440
break;
441441
case ZEND_INTERNAL_CLASS:
442+
if (ce->backed_enum_table) {
443+
zend_hash_release(ce->backed_enum_table);
444+
}
442445
if (ce->default_properties_table) {
443446
zval *p = ce->default_properties_table;
444447
zval *end = p + ce->default_properties_count;

0 commit comments

Comments
 (0)