Skip to content

Commit faa48e6

Browse files
dstogovdstogov
committed
Merge branch 'master' into jit-dynasm
* master: Renumber types and type_flags Always use IS_CONSTANT_AST (IS_CONSTANT is removed). Move dev to 7.0.26 Make GMP more usable by third-party extensions.
2 parents 42cb293 + dec8b78 commit faa48e6

37 files changed

+279
-268
lines changed

‎NEWS‎

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,9 @@ PHP NEWS
3232
- GD:
3333
. Added support for WebP in imagecreatefromstring() (Andreas Treichel, cmb).
3434

35+
- GMP:
36+
. Export internal structures and accessor helpers for GMP object. (Sara)
37+
3538
- LDAP:
3639
. Added ldap_exop_refresh helper for EXOP REFRESH operation with dds overlay.
3740
(Come)

‎UPGRADING.INTERNALS‎

Lines changed: 6 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -13,7 +13,7 @@ PHP 7.2 INTERNALS UPGRADE NOTES
1313
j. Run-time constant operand addressing
1414
k. Array/Object recursion protection
1515
l. HASH_FLAG_PERSISTENT
16-
m. zend_ast_ref
16+
m. AST and IS_CONSTANT
1717

1818
2. Build system changes
1919
a. Unix build system changes
@@ -94,6 +94,11 @@ PHP 7.2 INTERNALS UPGRADE NOTES
9494
zend_ast_destroy_and_free() is removed. ZVAL_NEW_AST() is replaced
9595
by ZVAL_AST().
9696

97+
IS_CONSTANT type and Z_CONST_FLAGS() are removed. Now constants are always
98+
represented using IS_CONSTANT_AST (ZEND_AST_CONSTANT kind). AST node
99+
attributes are used instead of constant flags. IS_TYPE_CONSTANT flag is
100+
removed, but Z_CONSTANT() macro is kept for compatibility.
101+
97102
========================
98103
2. Build system changes
99104
========================

‎Zend/zend_API.c‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -1150,7 +1150,7 @@ ZEND_API int zend_update_class_constants(zend_class_entry *class_type) /* {{{ */
11501150

11511151
ZEND_HASH_FOREACH_PTR(&class_type->constants_table, c) {
11521152
val = &c->value;
1153-
if (Z_CONSTANT_P(val)) {
1153+
if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
11541154
if (UNEXPECTED(zval_update_constant_ex(val, c->ce) != SUCCESS)) {
11551155
return FAILURE;
11561156
}
@@ -1167,7 +1167,7 @@ ZEND_API int zend_update_class_constants(zend_class_entry *class_type) /* {{{ */
11671167
val = (zval*)((char*)class_type->default_properties_table + prop_info->offset - OBJ_PROP_TO_OFFSET(0));
11681168
}
11691169
ZVAL_DEREF(val);
1170-
if (Z_CONSTANT_P(val)) {
1170+
if (Z_TYPE_P(val) == IS_CONSTANT_AST) {
11711171
if (UNEXPECTED(zval_update_constant_ex(val, ce) != SUCCESS)) {
11721172
return FAILURE;
11731173
}
@@ -3685,12 +3685,12 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, z
36853685

36863686
if (ce->type == ZEND_INTERNAL_CLASS) {
36873687
property_info = pemalloc(sizeof(zend_property_info), 1);
3688-
if ((access_type & ZEND_ACC_STATIC) || Z_CONSTANT_P(property)) {
3688+
if ((access_type & ZEND_ACC_STATIC) || Z_TYPE_P(property) == IS_CONSTANT_AST) {
36893689
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
36903690
}
36913691
} else {
36923692
property_info = zend_arena_alloc(&CG(arena), sizeof(zend_property_info));
3693-
if (Z_CONSTANT_P(property)) {
3693+
if (Z_TYPE_P(property) == IS_CONSTANT_AST) {
36943694
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
36953695
}
36963696
}
@@ -3846,7 +3846,7 @@ ZEND_API int zend_declare_class_constant_ex(zend_class_entry *ce, zend_string *n
38463846
Z_ACCESS_FLAGS(c->value) = access_type;
38473847
c->doc_comment = doc_comment;
38483848
c->ce = ce;
3849-
if (Z_CONSTANT_P(value)) {
3849+
if (Z_TYPE_P(value) == IS_CONSTANT_AST) {
38503850
ce->ce_flags &= ~ZEND_ACC_CONSTANTS_UPDATED;
38513851
}
38523852

‎Zend/zend_ast.c‎

Lines changed: 51 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,7 @@
2525
#include "zend_language_parser.h"
2626
#include "zend_smart_str.h"
2727
#include "zend_exceptions.h"
28+
#include "zend_constants.h"
2829

2930
ZEND_API zend_ast_process_t zend_ast_process = NULL;
3031

@@ -72,6 +73,17 @@ ZEND_API zend_ast *zend_ast_create_zval_ex(zval *zv, zend_ast_attr attr) {
7273
return zend_ast_create_zval_with_lineno(zv, attr, CG(zend_lineno));
7374
}
7475

76+
ZEND_API zend_ast *zend_ast_create_constant(zend_string *name, zend_ast_attr attr) {
77+
zend_ast_zval *ast;
78+
79+
ast = zend_ast_alloc(sizeof(zend_ast_zval));
80+
ast->kind = ZEND_AST_CONSTANT;
81+
ast->attr = attr;
82+
ZVAL_STR(&ast->val, name);
83+
ast->val.u2.lineno = CG(zend_lineno);
84+
return (zend_ast *) ast;
85+
}
86+
7587
ZEND_API zend_ast *zend_ast_create_decl(
7688
zend_ast_kind kind, uint32_t flags, uint32_t start_lineno, zend_string *doc_comment,
7789
zend_string *name, zend_ast *child0, zend_ast *child1, zend_ast *child2, zend_ast *child3
@@ -276,25 +288,30 @@ ZEND_API int zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *sc
276288
{
277289
zval *zv = zend_ast_get_zval(ast);
278290

279-
if (Z_OPT_CONSTANT_P(zv)) {
280-
if (Z_TYPE_FLAGS_P(zv) & IS_TYPE_REFCOUNTED) {
281-
if (UNEXPECTED(zval_update_constant_ex(zv, scope) != SUCCESS)) {
282-
ret = FAILURE;
283-
break;
284-
}
285-
ZVAL_COPY(result, zv);
286-
} else {
287-
ZVAL_COPY_VALUE(result, zv);
288-
if (UNEXPECTED(zval_update_constant_ex(result, scope) != SUCCESS)) {
289-
ret = FAILURE;
290-
break;
291-
}
292-
}
293-
} else {
294-
ZVAL_COPY(result, zv);
291+
ZVAL_COPY(result, zv);
292+
break;
293+
}
294+
case ZEND_AST_CONSTANT:
295+
{
296+
zend_string *name = zend_ast_get_constant_name(ast);
297+
zval *zv = zend_get_constant_ex(name, scope, ast->attr);
298+
299+
if (UNEXPECTED(zv == NULL)) {
300+
ZVAL_UNDEF(result);
301+
ret = zend_use_undefined_constant(name, ast->attr, result);
302+
break;
295303
}
304+
ZVAL_DUP(result, zv);
296305
break;
297306
}
307+
case ZEND_AST_CONSTANT_CLASS:
308+
ZEND_ASSERT(EG(current_execute_data));
309+
if (scope && scope->name) {
310+
ZVAL_STR_COPY(result, scope->name);
311+
} else {
312+
ZVAL_EMPTY_STRING(result);
313+
}
314+
break;
298315
case ZEND_AST_AND:
299316
if (UNEXPECTED(zend_ast_evaluate(&op1, ast->child[0], scope) != SUCCESS)) {
300317
ret = FAILURE;
@@ -455,7 +472,7 @@ static size_t zend_ast_tree_size(zend_ast *ast)
455472
{
456473
size_t size;
457474

458-
if (ast->kind == ZEND_AST_ZVAL) {
475+
if (ast->kind == ZEND_AST_ZVAL || ast->kind == ZEND_AST_CONSTANT) {
459476
size = sizeof(zend_ast_zval);
460477
} else if (zend_ast_is_list(ast)) {
461478
uint32_t i;
@@ -488,6 +505,12 @@ static void* zend_ast_tree_copy(zend_ast *ast, void *buf)
488505
new->attr = ast->attr;
489506
ZVAL_COPY(&new->val, zend_ast_get_zval(ast));
490507
buf = (void*)((char*)buf + sizeof(zend_ast_zval));
508+
} else if (ast->kind == ZEND_AST_CONSTANT) {
509+
zend_ast_zval *new = (zend_ast_zval*)buf;
510+
new->kind = ZEND_AST_CONSTANT;
511+
new->attr = ast->attr;
512+
ZVAL_STR_COPY(&new->val, zend_ast_get_constant_name(ast));
513+
buf = (void*)((char*)buf + sizeof(zend_ast_zval));
491514
} else if (zend_ast_is_list(ast)) {
492515
zend_ast_list *list = zend_ast_get_list(ast);
493516
zend_ast_list *new = (zend_ast_list*)buf;
@@ -548,6 +571,9 @@ ZEND_API void zend_ast_destroy(zend_ast *ast) {
548571
* become invalid. GC would cause such a reference in the root buffer. */
549572
zval_ptr_dtor_nogc(zend_ast_get_zval(ast));
550573
break;
574+
case ZEND_AST_CONSTANT:
575+
zend_string_release(zend_ast_get_constant_name(ast));
576+
break;
551577
case ZEND_AST_FUNC_DECL:
552578
case ZEND_AST_CLOSURE:
553579
case ZEND_AST_METHOD:
@@ -996,9 +1022,6 @@ static void zend_ast_export_zval(smart_str *str, zval *zv, int priority, int ind
9961022
} ZEND_HASH_FOREACH_END();
9971023
smart_str_appendc(str, ']');
9981024
break;
999-
case IS_CONSTANT:
1000-
smart_str_appendl(str, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
1001-
break;
10021025
case IS_CONSTANT_AST:
10031026
zend_ast_export_ex(str, Z_ASTVAL_P(zv), priority, indent);
10041027
break;
@@ -1078,6 +1101,14 @@ static void zend_ast_export_ex(smart_str *str, zend_ast *ast, int priority, int
10781101
case ZEND_AST_ZVAL:
10791102
zend_ast_export_zval(str, zend_ast_get_zval(ast), priority, indent);
10801103
break;
1104+
case ZEND_AST_CONSTANT: {
1105+
zend_string *name = zend_ast_get_constant_name(ast);
1106+
smart_str_appendl(str, ZSTR_VAL(name), ZSTR_LEN(name));
1107+
break;
1108+
}
1109+
case ZEND_AST_CONSTANT_CLASS:
1110+
smart_str_appendl(str, "__CLASS__", sizeof("__CLASS__")-1);
1111+
break;
10811112
case ZEND_AST_ZNODE:
10821113
/* This AST kind is only used for temporary nodes during compilation */
10831114
ZEND_ASSERT(0);

‎Zend/zend_ast.h‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -32,6 +32,7 @@
3232
enum _zend_ast_kind {
3333
/* special nodes */
3434
ZEND_AST_ZVAL = 1 << ZEND_AST_SPECIAL_SHIFT,
35+
ZEND_AST_CONSTANT,
3536
ZEND_AST_ZNODE,
3637

3738
/* declaration nodes */
@@ -61,6 +62,7 @@ enum _zend_ast_kind {
6162
/* 0 child nodes */
6263
ZEND_AST_MAGIC_CONST = 0 << ZEND_AST_NUM_CHILDREN_SHIFT,
6364
ZEND_AST_TYPE,
65+
ZEND_AST_CONSTANT_CLASS,
6466

6567
/* 1 child node */
6668
ZEND_AST_VAR = 1 << ZEND_AST_NUM_CHILDREN_SHIFT,
@@ -192,6 +194,8 @@ extern ZEND_API zend_ast_process_t zend_ast_process;
192194
ZEND_API zend_ast *zend_ast_create_zval_with_lineno(zval *zv, zend_ast_attr attr, uint32_t lineno);
193195
ZEND_API zend_ast *zend_ast_create_zval_ex(zval *zv, zend_ast_attr attr);
194196

197+
ZEND_API zend_ast *zend_ast_create_constant(zend_string *name, zend_ast_attr attr);
198+
195199
ZEND_API zend_ast *zend_ast_create_ex(zend_ast_kind kind, zend_ast_attr attr, ...);
196200
ZEND_API zend_ast *zend_ast_create(zend_ast_kind kind, ...);
197201

@@ -230,6 +234,12 @@ static zend_always_inline zend_string *zend_ast_get_str(zend_ast *ast) {
230234
return Z_STR_P(zv);
231235
}
232236

237+
static zend_always_inline zend_string *zend_ast_get_constant_name(zend_ast *ast) {
238+
ZEND_ASSERT(ast->kind == ZEND_AST_CONSTANT);
239+
ZEND_ASSERT(Z_TYPE(((zend_ast_zval *) ast)->val) == IS_STRING);
240+
return Z_STR(((zend_ast_zval *) ast)->val);
241+
}
242+
233243
static zend_always_inline uint32_t zend_ast_get_num_children(zend_ast *ast) {
234244
ZEND_ASSERT(!zend_ast_is_list(ast));
235245
return ast->kind >> ZEND_AST_NUM_CHILDREN_SHIFT;

‎Zend/zend_builtin_functions.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -1071,7 +1071,7 @@ static void add_class_vars(zend_class_entry *scope, zend_class_entry *ce, int st
10711071

10721072
/* this is necessary to make it able to work with default array
10731073
* properties, returned to user */
1074-
if (Z_OPT_CONSTANT_P(prop)) {
1074+
if (Z_OPT_TYPE_P(prop) == IS_CONSTANT_AST) {
10751075
if (UNEXPECTED(zval_update_constant_ex(prop, NULL) != SUCCESS)) {
10761076
return;
10771077
}

‎Zend/zend_compile.c‎

Lines changed: 19 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -460,7 +460,7 @@ void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */
460460
/* Common part of zend_add_literal and zend_append_individual_literal */
461461
static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int literal_position) /* {{{ */
462462
{
463-
if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
463+
if (Z_TYPE_P(zv) == IS_STRING) {
464464
zend_string_hash_val(Z_STR_P(zv));
465465
Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv));
466466
if (ZSTR_IS_INTERNED(Z_STR_P(zv))) {
@@ -5518,8 +5518,9 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast) /* {{{ */
55185518
zend_bool allow_null;
55195519
zend_bool has_null_default = default_ast
55205520
&& (Z_TYPE(default_node.u.constant) == IS_NULL
5521-
|| (Z_TYPE(default_node.u.constant) == IS_CONSTANT
5522-
&& strcasecmp(Z_STRVAL(default_node.u.constant), "NULL") == 0));
5521+
|| (Z_TYPE(default_node.u.constant) == IS_CONSTANT_AST
5522+
&& Z_ASTVAL(default_node.u.constant)->kind == ZEND_AST_CONSTANT
5523+
&& strcasecmp(ZSTR_VAL(zend_ast_get_constant_name(Z_ASTVAL(default_node.u.constant))), "NULL") == 0));
55235524
zend_bool is_explicitly_nullable = (type_ast->attr & ZEND_TYPE_NULLABLE) == ZEND_TYPE_NULLABLE;
55245525

55255526
op_array->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS;
@@ -5536,19 +5537,19 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast) /* {{{ */
55365537
if (ZEND_TYPE_CODE(arg_info->type) == IS_ARRAY) {
55375538
if (default_ast && !has_null_default
55385539
&& Z_TYPE(default_node.u.constant) != IS_ARRAY
5539-
&& !Z_CONSTANT(default_node.u.constant)
5540+
&& Z_TYPE(default_node.u.constant) != IS_CONSTANT_AST
55405541
) {
55415542
zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
55425543
"with array type can only be an array or NULL");
55435544
}
55445545
} else if (ZEND_TYPE_CODE(arg_info->type) == IS_CALLABLE && default_ast) {
5545-
if (!has_null_default && !Z_CONSTANT(default_node.u.constant)) {
5546+
if (!has_null_default && Z_TYPE(default_node.u.constant) != IS_CONSTANT_AST) {
55465547
zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
55475548
"with callable type can only be NULL");
55485549
}
55495550
}
55505551
} else {
5551-
if (default_ast && !has_null_default && !Z_CONSTANT(default_node.u.constant)) {
5552+
if (default_ast && !has_null_default && Z_TYPE(default_node.u.constant) != IS_CONSTANT_AST) {
55525553
if (ZEND_TYPE_IS_CLASS(arg_info->type)) {
55535554
zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters "
55545555
"with a class type can only be NULL");
@@ -7916,6 +7917,7 @@ void zend_compile_const_expr_class_const(zend_ast **ast_ptr) /* {{{ */
79167917
zend_ast *const_ast = ast->child[1];
79177918
zend_string *class_name;
79187919
zend_string *const_name = zend_ast_get_str(const_ast);
7920+
zend_string *name;
79197921
zval result;
79207922
int fetch_type;
79217923

@@ -7943,16 +7945,13 @@ void zend_compile_const_expr_class_const(zend_ast **ast_ptr) /* {{{ */
79437945
zend_string_addref(class_name);
79447946
}
79457947

7946-
Z_STR(result) = zend_concat3(
7948+
name = zend_concat3(
79477949
ZSTR_VAL(class_name), ZSTR_LEN(class_name), "::", 2, ZSTR_VAL(const_name), ZSTR_LEN(const_name));
79487950

7949-
Z_TYPE_INFO(result) = IS_CONSTANT_EX;
7950-
Z_CONST_FLAGS(result) = fetch_type;
7951-
79527951
zend_ast_destroy(ast);
79537952
zend_string_release(class_name);
79547953

7955-
*ast_ptr = zend_ast_create_zval(&result);
7954+
*ast_ptr = zend_ast_create_constant(name, fetch_type);
79567955
}
79577956
/* }}} */
79587957

@@ -7962,25 +7961,21 @@ void zend_compile_const_expr_const(zend_ast **ast_ptr) /* {{{ */
79627961
zend_ast *name_ast = ast->child[0];
79637962
zend_string *orig_name = zend_ast_get_str(name_ast);
79647963
zend_bool is_fully_qualified;
7964+
zval result;
7965+
zend_string *resolved_name;
79657966

7966-
zval result, resolved_name;
7967-
ZVAL_STR(&resolved_name, zend_resolve_const_name(
7968-
orig_name, name_ast->attr, &is_fully_qualified));
7967+
resolved_name = zend_resolve_const_name(
7968+
orig_name, name_ast->attr, &is_fully_qualified);
79697969

7970-
if (zend_try_ct_eval_const(&result, Z_STR(resolved_name), is_fully_qualified)) {
7971-
zend_string_release(Z_STR(resolved_name));
7970+
if (zend_try_ct_eval_const(&result, resolved_name, is_fully_qualified)) {
7971+
zend_string_release(resolved_name);
79727972
zend_ast_destroy(ast);
79737973
*ast_ptr = zend_ast_create_zval(&result);
79747974
return;
79757975
}
79767976

7977-
Z_TYPE_INFO(resolved_name) = IS_CONSTANT_EX;
7978-
if (!is_fully_qualified) {
7979-
Z_CONST_FLAGS(resolved_name) = IS_CONSTANT_UNQUALIFIED;
7980-
}
7981-
79827977
zend_ast_destroy(ast);
7983-
*ast_ptr = zend_ast_create_zval(&resolved_name);
7978+
*ast_ptr = zend_ast_create_constant(resolved_name, !is_fully_qualified ? IS_CONSTANT_UNQUALIFIED : 0);
79847979
}
79857980
/* }}} */
79867981

@@ -7993,14 +7988,8 @@ void zend_compile_const_expr_magic_const(zend_ast **ast_ptr) /* {{{ */
79937988
CG(active_class_entry) &&
79947989
(CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != 0);
79957990

7996-
{
7997-
zval const_zv;
7998-
Z_STR(const_zv) = zend_string_init("__CLASS__", sizeof("__CLASS__")-1, 0);
7999-
Z_TYPE_INFO(const_zv) = IS_CONSTANT_EX | (IS_CONSTANT_CLASS << Z_CONST_FLAGS_SHIFT);
8000-
8001-
zend_ast_destroy(ast);
8002-
*ast_ptr = zend_ast_create_zval(&const_zv);
8003-
}
7991+
zend_ast_destroy(ast);
7992+
*ast_ptr = zend_ast_create_ex(ZEND_AST_CONSTANT_CLASS, 0);
80047993
}
80057994
/* }}} */
80067995

‎Zend/zend_compile.h‎

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -886,6 +886,10 @@ void zend_assert_valid_class_name(const zend_string *const_name);
886886

887887
#define ZEND_DIM_IS 1
888888

889+
#define IS_CONSTANT_UNQUALIFIED 0x010
890+
#define IS_CONSTANT_CLASS 0x080 /* __CLASS__ in trait */
891+
#define IS_CONSTANT_IN_NAMESPACE 0x100
892+
889893
static zend_always_inline int zend_check_arg_send_type(const zend_function *zf, uint32_t arg_num, uint32_t mask)
890894
{
891895
arg_num--;

‎Zend/zend_constants.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -348,7 +348,7 @@ ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope,
348348
}
349349
}
350350

351-
if (ret_constant && Z_CONSTANT_P(ret_constant)) {
351+
if (ret_constant && Z_TYPE_P(ret_constant) == IS_CONSTANT_AST) {
352352
if (Z_TYPE_P(ret_constant) == IS_CONSTANT_AST) {
353353
if (IS_CONSTANT_VISITED(ret_constant)) {
354354
zend_throw_error(NULL, "Cannot declare self-referencing constant '%s::%s'", ZSTR_VAL(class_name), ZSTR_VAL(constant_name));

‎Zend/zend_execute.c‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -729,7 +729,7 @@ static ZEND_COLD void zend_verify_arg_error(
729729

730730
static int is_null_constant(zend_class_entry *scope, zval *default_value)
731731
{
732-
if (Z_CONSTANT_P(default_value)) {
732+
if (Z_TYPE_P(default_value) == IS_CONSTANT_AST) {
733733
zval constant;
734734

735735
ZVAL_COPY(&constant, default_value);

0 commit comments

Comments
 (0)