Introduced struct zend_attribute. Defer ASt evaluation to access time.

Author: kooldev

Zend/zend_attributes.c

@@ -2,14 +2,14 @@
 #include "zend_API.h"
 #include "zend_attributes.h"
 
-void zend_attribute_validate_phpattribute(zval *attribute, int target)
+void zend_attribute_validate_phpattribute(zend_attribute *attr, int target)
 {
 	if (target != ZEND_ATTRIBUTE_TARGET_CLASS) {
 		zend_error(E_COMPILE_ERROR, "Only classes can be marked with <<PhpAttribute>>");
 	}
 }
 
-void zend_attribute_validate_phpcompilerattribute(zval *attribute, int target)
+void zend_attribute_validate_phpcompilerattribute(zend_attribute *attr, int target)
 {
 	zend_error(E_COMPILE_ERROR, "The PhpCompilerAttribute can only be used by internal classes, use PhpAttribute instead");
 }

Zend/zend_attributes.h

@@ -12,7 +12,43 @@
 zend_class_entry *zend_ce_php_attribute;
 zend_class_entry *zend_ce_php_compiler_attribute;
 
-typedef void (*zend_attributes_internal_validator)(zval *attribute, int target);
+typedef struct _zend_attribute {
+	zend_string *name;
+	zend_string *lcname;
+	uint32_t offset;
+	uint32_t argc;
+	zval argv[1];
+} zend_attribute;
+
+static zend_always_inline zend_bool zend_has_attribute(HashTable *attributes, zend_string *name, uint32_t offset)
+{
+	if (attributes) {
+		zend_attribute *attr;
+
+		ZEND_HASH_FOREACH_PTR(attributes, attr) {
+			if (attr->offset == offset && zend_string_equals(attr->lcname, name)) {
+				return 1;
+			}
+		} ZEND_HASH_FOREACH_END();
+	}
+
+	return 0;
+}
+
+static zend_always_inline zend_bool zend_has_attribute_str(HashTable *attributes, const char *str, size_t len, uint32_t offset)
+{
+	zend_bool result = 0;
+
+	if (attributes) {
+		zend_string *name = zend_string_init(str, len, 0);
+		result = zend_has_attribute(attributes, name, offset);
+		zend_string_release(name);
+	}
+
+	return result;
+}
+
+typedef void (*zend_attributes_internal_validator)(zend_attribute *attr, int target);
 HashTable zend_attributes_internal_validators;
 
 void zend_compiler_attribute_register(zend_class_entry *ce, zend_attributes_internal_validator validator);

Zend/zend_compile.c

@@ -5717,89 +5717,81 @@ static zend_bool zend_is_valid_default_value(zend_type type, zval *value)
 	return 0;
 }
 
-static void zend_compile_attribute(zval *v, zend_ast *ast) /* {{{ */
+static zend_attribute *zend_compile_attribute(zend_ast *ast, uint32_t offset) /* {{{ */
 {
 	ZEND_ASSERT(ast->kind == ZEND_AST_ATTRIBUTE);
 
-	array_init_size(v, 1 + (ast->child[1] ? zend_ast_get_list(ast->child[1])->children : 0));
-	add_next_index_str(v, zend_resolve_class_name_ast(ast->child[0]));
+	zend_ast_list *list = ast->child[1] ? zend_ast_get_list(ast->child[1]) : NULL;
+	zend_attribute *attr = emalloc(sizeof(zend_attribute) + sizeof(zval) * (list ? list->children : 0));
 
-	if (ast->child[1]) {
-		zend_ast_list *list = zend_ast_get_list(ast->child[1]);
-		uint32_t i;
-		zval tmp;
+	attr->name = zend_resolve_class_name_ast(ast->child[0]);
+	attr->lcname = zend_string_tolower(attr->name);
+	attr->offset = offset;
+	attr->argc = list ? list->children : 0;
 
+	if (ast->child[1]) {
 		ZEND_ASSERT(ast->child[1]->kind == ZEND_AST_ARG_LIST);
 
-		ZVAL_NULL(&tmp);
+		uint32_t i;
 
 		for (i = 0; i < list->children; i++) {
-			zend_const_expr_to_zval(zend_hash_next_index_insert(Z_ARRVAL_P(v), &tmp), list->child[i]);
+			zend_const_expr_to_zval(&attr->argv[i], list->child[i]);
 		}
 	}
+
+	return attr;
 }
 /* }}} */
 
-static HashTable *zend_compile_attributes(zend_ast *ast, int target) /* {{{ */
+static void attribute_ptr_dtor(zval *v) /* {{{ */
 {
-	HashTable *attr;
-
-	zend_ast_list *list = zend_ast_get_list(ast);
+	zend_attribute *attr = Z_PTR_P(v);
 	uint32_t i;
 
-	zval tmp;
-
-	ZVAL_NULL(&tmp);
+	zend_string_release(attr->name);
+	zend_string_release(attr->lcname);
 
-	ZEND_ASSERT(ast->kind == ZEND_AST_ATTRIBUTE_LIST);
-
-	ALLOC_HASHTABLE(attr);
-	zend_hash_init(attr, zend_ast_get_list(ast)->children, NULL, ZVAL_PTR_DTOR, 0);
-
-	for (i = 0; i < list->children; i++) {
-		zend_ast *el = list->child[i];
-		zend_string *name;
+	for (i = 0; i < attr->argc; i++) {
+		zval_ptr_dtor(&attr->argv[i]);
+	}
 
-		zval a;
-		zval *x;
+	efree(attr);
+}
+/* }}} */
 
-		zend_compile_attribute(&a, el);
+static zend_always_inline HashTable *create_attribute_array(uint32_t size) /* {{{ */
+{
+	HashTable *attributes;
 
-		name = zend_string_tolower(Z_STR_P(zend_hash_index_find(Z_ARRVAL(a), 0)));
-		x = zend_hash_find(attr, name);
+	ALLOC_HASHTABLE(attributes);
+	zend_hash_init(attributes, size, NULL, attribute_ptr_dtor, 0);
 
-		// Validate internal attribute
-		zend_attributes_internal_validator validator = zend_hash_find_ptr(&zend_attributes_internal_validators, name);
+	return attributes;
+}
+/* }}} */
 
-		if (validator != NULL) {
-			validator(&a, target);
-		}
+static void zend_compile_attributes(HashTable *attributes, zend_ast *ast, uint32_t offset, int target) /* {{{ */
+{
+	zend_ast_list *list = zend_ast_get_list(ast);
+	uint32_t i;
 
-		if (x) {
-			ZEND_ASSERT(Z_TYPE_P(x) == IS_ARRAY);
+	zval tmp;
 
-			if (Z_TYPE_P(zend_hash_index_find(Z_ARRVAL_P(x), 0)) == IS_ARRAY) {
-				add_next_index_zval(x, &a);
-			} else {
-				zval array;
+	ZEND_ASSERT(ast->kind == ZEND_AST_ATTRIBUTE_LIST);
 
-				ZEND_ASSERT(Z_TYPE_P(zend_hash_index_find(Z_ARRVAL_P(x), 0)) == IS_STRING);
+	for (i = 0; i < list->children; i++) {
+		zend_attribute *attr = zend_compile_attribute(list->child[i], 0);
 
-				Z_ADDREF_P(x);
+		// Validate internal attribute
+		zend_attributes_internal_validator validator = zend_hash_find_ptr(&zend_attributes_internal_validators, attr->lcname);
 
-				array_init(&array);
-				add_next_index_zval(&array, x);
-				add_next_index_zval(&array, &a);
-				zend_hash_update(attr, name, &array);
-			}
-		} else {
-			zend_hash_add(attr, name, &a);
+		if (validator != NULL) {
+			validator(attr, target);
 		}
 
-		zend_string_release(name);
+		ZVAL_PTR(&tmp, attr);
+		zend_hash_next_index_insert(attributes, &tmp);
 	}
-
-	return attr;
 }
 /* }}} */
 
@@ -5908,15 +5900,11 @@ void zend_compile_params(zend_ast *ast, zend_ast *return_type_ast, uint32_t fall
 		arg_info->type = (zend_type) ZEND_TYPE_INIT_NONE(0);
 
 		if (attributes_ast) {
-			zval attr;
-
 			if (!op_array->attributes) {
-				ALLOC_HASHTABLE(op_array->attributes);
-				zend_hash_init(op_array->attributes, 8, NULL, ZVAL_PTR_DTOR, 0);
+				op_array->attributes = create_attribute_array(zend_ast_get_list(attributes_ast)->children);
 			}
 
-			ZVAL_ARR(&attr, zend_compile_attributes(attributes_ast, ZEND_ATTRIBUTE_TARGET_PARAMETER));
-			zend_hash_index_add(op_array->attributes, i, &attr);
+			zend_compile_attributes(op_array->attributes, attributes_ast, i + 1, ZEND_ATTRIBUTE_TARGET_PARAMETER);
 		}
 
 		if (type_ast) {
@@ -6376,10 +6364,12 @@ void zend_compile_func_decl(znode *result, zend_ast *ast, zend_bool toplevel) /*
 	}
 	if (decl->attributes) {
 		int target = ZEND_ATTRIBUTE_TARGET_FUNCTION;
+
 		if (is_method) {
 			target = ZEND_ATTRIBUTE_TARGET_METHOD;
 		}
-		op_array->attributes = zend_compile_attributes(decl->attributes, target);
+		op_array->attributes = create_attribute_array(zend_ast_get_list(decl->attributes)->children);
+		zend_compile_attributes(op_array->attributes, decl->attributes, 0, target);
 	}
 	if (decl->kind == ZEND_AST_CLOSURE || decl->kind == ZEND_AST_ARROW_FUNC) {
 		op_array->fn_flags |= ZEND_ACC_CLOSURE;
@@ -6548,12 +6538,15 @@ void zend_compile_prop_decl(zend_ast *ast, zend_ast *type_ast, uint32_t flags, H
 
 void zend_compile_prop_group(zend_ast *list) /* {{{ */
 {
-	HashTable *attributes;
+	HashTable *attributes = NULL;
 
 	zend_ast *type_ast = list->child[0];
 	zend_ast *prop_ast = list->child[1];
 
-	attributes = list->child[2] ? zend_compile_attributes(list->child[2], ZEND_ATTRIBUTE_TARGET_PROPERTY) : NULL;
+	if (list->child[2]) {
+		attributes = create_attribute_array(zend_ast_get_list(list->child[2])->children);
+		zend_compile_attributes(attributes, list->child[2], 0, ZEND_ATTRIBUTE_TARGET_PROPERTY);
+	}
 
 	zend_compile_prop_decl(prop_ast, type_ast, list->attr, attributes);
 
@@ -6579,15 +6572,18 @@ void zend_compile_class_const_decl(zend_ast *ast, zend_ast *attr_ast) /* {{{ */
 {
 	zend_ast_list *list = zend_ast_get_list(ast);
 	zend_class_entry *ce = CG(active_class_entry);
-	HashTable *attributes;
+	HashTable *attributes = NULL;
 	uint32_t i;
 
 	if ((ce->ce_flags & ZEND_ACC_TRAIT) != 0) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants");
 		return;
 	}
 
-	attributes = attr_ast ? zend_compile_attributes(attr_ast, ZEND_ATTRIBUTE_TARGET_CLASS_CONST) : NULL;
+	if (attr_ast) {
+		attributes = create_attribute_array(zend_ast_get_list(attr_ast)->children);
+		zend_compile_attributes(attributes, attr_ast, 0, ZEND_ATTRIBUTE_TARGET_CLASS_CONST);
+	}
 
 	for (i = 0; i < list->children; ++i) {
 		zend_ast *const_ast = list->child[i];
@@ -6818,7 +6814,8 @@ zend_op *zend_compile_class_decl(zend_ast *ast, zend_bool toplevel) /* {{{ */
 		ce->info.user.doc_comment = zend_string_copy(decl->doc_comment);
 	}
 	if (decl->attributes) {
-		ce->info.user.attributes = zend_compile_attributes(decl->attributes, ZEND_ATTRIBUTE_TARGET_CLASS);
+		ce->info.user.attributes = create_attribute_array(zend_ast_get_list(decl->attributes)->children);
+		zend_compile_attributes(ce->info.user.attributes, decl->attributes, 0, ZEND_ATTRIBUTE_TARGET_CLASS);
 	}
 
 	if (UNEXPECTED((decl->flags & ZEND_ACC_ANON_CLASS))) {