Store original AST as string for zend_ast_op_array

Author: TimWolla

Zend/zend_ast.c

@@ -100,14 +100,16 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_constant(zend_string *name, ze
 	return (zend_ast *) ast;
 }
 
-ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_op_array(zend_op_array *op_array, zend_ast *original_ast, zend_ast_attr attr) {
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_op_array(zend_op_array *op_array, zend_string *original_ast) {
 	zend_ast_op_array *ast;
 
 	ast = zend_ast_alloc(sizeof(zend_ast_op_array));
 	ast->kind = ZEND_AST_OP_ARRAY;
-	ast->attr = attr;
+	ast->attr = 0;
+	ast->lineno = CG(zend_lineno);
 	ast->op_array = op_array;
-	ast->ast = original_ast;
+	ZEND_ASSERT(ZSTR_IS_INTERNED(original_ast));
+	ast->original_ast = original_ast;
 
 	return (zend_ast *) ast;
 }
@@ -1091,7 +1093,7 @@ static size_t ZEND_FASTCALL zend_ast_tree_size(zend_ast *ast)
 	if (ast->kind == ZEND_AST_ZVAL || ast->kind == ZEND_AST_CONSTANT) {
 		size = sizeof(zend_ast_zval);
 	} else if (ast->kind == ZEND_AST_OP_ARRAY) {
-		size = sizeof(zend_ast_op_array) + zend_ast_tree_size(zend_ast_get_op_array(ast)->ast);
+		size = sizeof(zend_ast_op_array);
 	} else if (zend_ast_is_list(ast)) {
 		uint32_t i;
 		zend_ast_list *list = zend_ast_get_list(ast);
@@ -1103,13 +1105,8 @@ static size_t ZEND_FASTCALL zend_ast_tree_size(zend_ast *ast)
 			}
 		}
 	} else if (zend_ast_is_decl(ast)) {
-		zend_ast_decl *decl = (zend_ast_decl*)ast;
-		size = sizeof(zend_ast_decl);
-		for (size_t i = 0; i < 5; i++) {
-			if (decl->child[i]) {
-				size += zend_ast_tree_size(decl->child[i]);
-			}
-		}
+		/* Not implemented. */
+		ZEND_UNREACHABLE();
 	} else {
 		uint32_t i, children = zend_ast_get_num_children(ast);
 
@@ -1161,38 +1158,13 @@ static void* ZEND_FASTCALL zend_ast_tree_copy(zend_ast *ast, void *buf)
 		zend_ast_op_array *new = (zend_ast_op_array*)buf;
 		new->kind = old->kind;
 		new->attr = old->attr;
+		new->lineno = old->lineno;
 		new->op_array = old->op_array;
+		new->original_ast = old->original_ast;
 		buf = (void*)((char*)buf + sizeof(zend_ast_op_array));
-		new->ast = (zend_ast*)buf;
-		buf = zend_ast_tree_copy(old->ast, buf);
 	} else if (zend_ast_is_decl(ast)) {
-		zend_ast_decl *old = (zend_ast_decl*)ast;
-		zend_ast_decl *new = (zend_ast_decl*)buf;
-		new->kind = old->kind;
-		new->attr = old->attr;
-		new->start_lineno = old->start_lineno;
-		new->end_lineno = old->end_lineno;
-		new->flags = old->flags;
-		if (old->doc_comment) {
-			new->doc_comment = zend_string_copy(old->doc_comment);
-		} else {
-			new->doc_comment = NULL;
-		}
-		if (old->name) {
-			new->name = zend_string_copy(old->name);
-		} else {
-			new->name = NULL;
-		}
-
-		buf = (void*)((char*)buf + sizeof(zend_ast_decl));
-		for (size_t i = 0; i < 5; i++) {
-			if (old->child[i]) {
-				new->child[i] = (zend_ast*)buf;
-				buf = zend_ast_tree_copy(old->child[i], buf);
-			} else {
-				new->child[i] = NULL;
-			}
-		}
+		/* Not implemented. */
+		ZEND_UNREACHABLE();
 	} else {
 		uint32_t i, children = zend_ast_get_num_children(ast);
 		zend_ast *new = (zend_ast*)buf;
@@ -1257,8 +1229,8 @@ ZEND_API void ZEND_FASTCALL zend_ast_destroy(zend_ast *ast)
 	} else if (EXPECTED(ast->kind == ZEND_AST_CONSTANT)) {
 		zend_string_release_ex(zend_ast_get_constant_name(ast), 0);
 	} else if (EXPECTED(ast->kind == ZEND_AST_OP_ARRAY)) {
-		zend_ast_destroy(zend_ast_get_op_array(ast)->ast);
-	} else if (zend_ast_is_decl(ast)) {
+		zend_string_release_ex(zend_ast_get_op_array(ast)->original_ast, 0);
+	} else if (EXPECTED(zend_ast_is_decl(ast))) {
 		zend_ast_decl *decl = (zend_ast_decl *) ast;
 
 		if (decl->name) {
@@ -1875,10 +1847,9 @@ static ZEND_COLD void zend_ast_export_ex(smart_str *str, zend_ast *ast, int prio
 			smart_str_appendl(str, ZSTR_VAL(name), ZSTR_LEN(name));
 			break;
 		}
-		case ZEND_AST_OP_ARRAY: {
-			zend_ast_export_ex(str, zend_ast_get_op_array(ast)->ast, priority, indent);
+		case ZEND_AST_OP_ARRAY:
+			smart_str_append(str, zend_ast_get_op_array(ast)->original_ast);
 			break;
-		}
 		case ZEND_AST_CONSTANT_CLASS:
 			smart_str_appendl(str, "__CLASS__", sizeof("__CLASS__")-1);
 			break;

Zend/zend_ast.h

@@ -212,8 +212,9 @@ typedef struct _zend_op_array zend_op_array;
 typedef struct _zend_ast_op_array {
 	zend_ast_kind kind;
 	zend_ast_attr attr;
+	uint32_t lineno;
 	zend_op_array *op_array;
-	zend_ast *ast;
+	zend_string *original_ast;
 } zend_ast_op_array;
 
 /* Separate structure for function and class declaration, as they need extra information. */
@@ -240,7 +241,7 @@ ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_zval_from_long(zend_long lval)
 ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_constant(zend_string *name, zend_ast_attr attr);
 ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_class_const_or_name(zend_ast *class_name, zend_ast *name);
 
-ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_op_array(zend_op_array *op_array, zend_ast *original_ast, zend_ast_attr attr);
+ZEND_API zend_ast * ZEND_FASTCALL zend_ast_create_op_array(zend_op_array *op_array, zend_string *original_ast);
 
 #if ZEND_AST_SPEC
 # define ZEND_AST_SPEC_CALL(name, ...) \
@@ -386,8 +387,6 @@ static zend_always_inline uint32_t zend_ast_get_lineno(zend_ast *ast) {
 	} else if (ast->kind == ZEND_AST_CONSTANT) {
 		zval *zv = &((zend_ast_zval *) ast)->val;
 		return Z_LINENO_P(zv);
-	} else if (ast->kind == ZEND_AST_OP_ARRAY) {
-		return zend_ast_get_op_array(ast)->ast->lineno;
 	} else {
 		return ast->lineno;
 	}

Zend/zend_compile.c

@@ -11222,7 +11222,10 @@ static void zend_compile_const_expr_closure(zend_ast **ast_ptr)
 	znode node;
 	zend_op_array *op = zend_compile_func_decl(&node, (zend_ast*)closure_ast, FUNC_DECL_LEVEL_CONSTEXPR);
 
-	*ast_ptr = zend_ast_create_op_array(op, (zend_ast*)closure_ast, 0);
+	zend_string *original_ast = zend_new_interned_string(zend_ast_export("", *ast_ptr, ""));
+	zend_ast_destroy(*ast_ptr);
+	*ast_ptr = zend_ast_create_op_array(op, original_ast);
+
 }
 
 static void zend_compile_const_expr_args(zend_ast **ast_ptr)

ext/opcache/zend_file_cache.c

@@ -367,20 +367,10 @@ static void zend_file_cache_serialize_ast(zend_ast                 *ast,
 		/* The op_array itself will be serialized as part of the dynamic_func_defs. */
 		SERIALIZE_PTR(((zend_ast_op_array*)ast)->op_array);
 
-		SERIALIZE_PTR(((zend_ast_op_array*)ast)->ast);
-		tmp = ((zend_ast_op_array*)ast)->ast;
-		UNSERIALIZE_PTR(tmp);
-		zend_file_cache_serialize_ast(tmp, script, info, buf);
+		SERIALIZE_STR(((zend_ast_op_array*)ast)->original_ast);
 	} else if (zend_ast_is_decl(ast)) {
-		zend_ast_decl *decl = (zend_ast_decl*)ast;
-		for (i = 0; i < 5; i++) {
-			if (decl->child[i] && !IS_SERIALIZED(decl->child[i])) {
-				SERIALIZE_PTR(decl->child[i]);
-				tmp = decl->child[i];
-				UNSERIALIZE_PTR(tmp);
-				zend_file_cache_serialize_ast(tmp, script, info, buf);
-			}
-		}
+		/* Not implemented. */
+		ZEND_UNREACHABLE();
 	} else {
 		uint32_t children = zend_ast_get_num_children(ast);
 		for (i = 0; i < children; i++) {
@@ -1264,16 +1254,10 @@ static void zend_file_cache_unserialize_ast(zend_ast                *ast,
 		/* The op_array itself will be unserialized as part of the dynamic_func_defs. */
 		UNSERIALIZE_PTR(((zend_ast_op_array*)ast)->op_array);
 
-		UNSERIALIZE_PTR(((zend_ast_op_array*)ast)->ast);
-		zend_file_cache_unserialize_ast(((zend_ast_op_array*)ast)->ast, script, buf);
+		UNSERIALIZE_STR(((zend_ast_op_array*)ast)->original_ast);
 	} else if (zend_ast_is_decl(ast)) {
-		zend_ast_decl *decl = (zend_ast_decl*)ast;
-		for (i = 0; i < 5; i++) {
-			if (decl->child[i] && !IS_UNSERIALIZED(decl->child[i])) {
-				UNSERIALIZE_PTR(decl->child[i]);
-				zend_file_cache_unserialize_ast(decl->child[i], script, buf);
-			}
-		}
+		/* Not implemented. */
+		ZEND_UNREACHABLE();
 	} else {
 		uint32_t children = zend_ast_get_num_children(ast);
 		for (i = 0; i < children; i++) {

ext/opcache/zend_persist.c

@@ -194,16 +194,11 @@ static zend_ast *zend_persist_ast(zend_ast *ast)
 		ZVAL_PTR(&z, copy->op_array);
 		zend_persist_op_array(&z);
 		copy->op_array = Z_PTR(z);
-		copy->ast = zend_persist_ast(copy->ast);
+		zend_accel_store_interned_string(copy->original_ast);
 		node = (zend_ast *) copy;
 	} else if (zend_ast_is_decl(ast)) {
-		zend_ast_decl *copy = zend_shared_memdup(ast, sizeof(zend_ast_decl));
-		for (i = 0; i < 5; i++) {
-			if (copy->child[i]) {
-				copy->child[i] = zend_persist_ast(copy->child[i]);
-			}
-		}
-		node = (zend_ast *) copy;
+		/* Not implemented. */
+		ZEND_UNREACHABLE();
 	} else {
 		uint32_t children = zend_ast_get_num_children(ast);
 		node = zend_shared_memdup(ast, zend_ast_size(children));

ext/opcache/zend_persist_calc.c

@@ -91,15 +91,10 @@ static void zend_persist_ast_calc(zend_ast *ast)
 		zval z;
 		ZVAL_PTR(&z, zend_ast_get_op_array(ast)->op_array);
 		zend_persist_op_array_calc(&z);
-		zend_persist_ast_calc(zend_ast_get_op_array(ast)->ast);
+		ADD_INTERNED_STRING(zend_ast_get_op_array(ast)->original_ast);
 	} else if (zend_ast_is_decl(ast)) {
-		zend_ast_decl *decl = (zend_ast_decl*)ast;
-		ADD_SIZE(sizeof(zend_ast_decl));
-		for (size_t i = 0; i < 5; i++) {
-			if (decl->child[i]) {
-				zend_persist_ast_calc(decl->child[i]);
-			}
-		}
+		/* Not implemented. */
+		ZEND_UNREACHABLE();
 	} else {
 		uint32_t children = zend_ast_get_num_children(ast);
 		ADD_SIZE(zend_ast_size(children));