Fixed bug #69388

Renamed compiler_context to oparray_context. Introduced per-file
file_context. Moved import tables into the file_context.

context_stack no longer exists, instead keeping backups of contexts
on C stack. Same for file contexts.

TODO: Move more things out of CG into file_context. There should be
a number of other things that we should not try to reuse in nested
compilations.

Author: nikic

Zend/zend.c

@@ -1047,7 +1047,6 @@ static void zend_error_va_list(int type, const char *format, va_list args)
 	zend_class_entry *saved_class_entry;
 	zend_stack loop_var_stack;
 	zend_stack delayed_oplines_stack;
-	zend_stack context_stack;
 	zend_array *symbol_table;
 
 	if (type & E_EXCEPTION) {
@@ -1234,7 +1233,6 @@ static void zend_error_va_list(int type, const char *format, va_list args)
 				CG(active_class_entry) = NULL;
 				SAVE_STACK(loop_var_stack);
 				SAVE_STACK(delayed_oplines_stack);
-				SAVE_STACK(context_stack);
 				CG(in_compilation) = 0;
 			}
 
@@ -1254,7 +1252,6 @@ static void zend_error_va_list(int type, const char *format, va_list args)
 				CG(active_class_entry) = saved_class_entry;
 				RESTORE_STACK(loop_var_stack);
 				RESTORE_STACK(delayed_oplines_stack);
-				RESTORE_STACK(context_stack);
 				CG(in_compilation) = 1;
 			}
 

Zend/zend_compile.c

@@ -225,8 +225,9 @@ static void init_compiler_declarables(void) /* {{{ */
 }
 /* }}} */
 
-void zend_init_compiler_context(void) /* {{{ */
+void zend_oparray_context_begin(zend_oparray_context *prev_context) /* {{{ */
 {
+	*prev_context = CG(context);
 	CG(context).opcodes_size = INITIAL_OP_ARRAY_SIZE;
 	CG(context).vars_size = 0;
 	CG(context).literals_size = 0;
@@ -238,6 +239,56 @@ void zend_init_compiler_context(void) /* {{{ */
 }
 /* }}} */
 
+void zend_oparray_context_end(zend_oparray_context *prev_context) /* {{{ */
+{
+	if (CG(context).labels) {
+		zend_hash_destroy(CG(context).labels);
+		FREE_HASHTABLE(CG(context).labels);
+		CG(context).labels = NULL;
+	}
+	CG(context) = *prev_context;
+}
+/* }}} */
+
+static void zend_reset_import_tables(void) /* {{{ */
+{
+	zend_file_context *ctx = &CG(file_context);
+	if (ctx->imports) {
+		zend_hash_destroy(ctx->imports);
+		efree(ctx->imports);
+		ctx->imports = NULL;
+	}
+
+	if (ctx->imports_function) {
+		zend_hash_destroy(ctx->imports_function);
+		efree(ctx->imports_function);
+		ctx->imports_function = NULL;
+	}
+
+	if (ctx->imports_const) {
+		zend_hash_destroy(ctx->imports_const);
+		efree(ctx->imports_const);
+		ctx->imports_const = NULL;
+	}
+}
+/* }}} */
+
+void zend_file_context_begin(zend_file_context *prev_context) /* {{{ */
+{
+	*prev_context = CG(file_context);
+	CG(file_context).imports = NULL;
+	CG(file_context).imports_function = NULL;
+	CG(file_context).imports_const = NULL;
+}
+/* }}} */
+
+void zend_file_context_end(zend_file_context *prev_context) /* {{{ */
+{
+	zend_reset_import_tables();
+	CG(file_context) = *prev_context;
+}
+/* }}} */
+
 void zend_init_compiler_data_structures(void) /* {{{ */
 {
 	zend_stack_init(&CG(loop_var_stack), sizeof(znode));
@@ -248,12 +299,8 @@ void zend_init_compiler_data_structures(void) /* {{{ */
 	CG(current_namespace) = NULL;
 	CG(in_namespace) = 0;
 	CG(has_bracketed_namespaces) = 0;
-	CG(current_import) = NULL;
-	CG(current_import_function) = NULL;
-	CG(current_import_const) = NULL;
 	zend_hash_init(&CG(const_filenames), 8, NULL, NULL, 0);
 	init_compiler_declarables();
-	zend_stack_init(&CG(context_stack), sizeof(CG(context)));
 
 	CG(encoding_declared) = 0;
 }
@@ -285,7 +332,6 @@ void shutdown_compiler(void) /* {{{ */
 	zend_stack_destroy(&CG(delayed_oplines_stack));
 	zend_hash_destroy(&CG(filenames_table));
 	zend_hash_destroy(&CG(const_filenames));
-	zend_stack_destroy(&CG(context_stack));
 	zend_arena_destroy(CG(arena));
 }
 /* }}} */
@@ -731,10 +777,10 @@ zend_string *zend_resolve_non_class_name(
 		*is_fully_qualified = 1;
 	}
 
-	if (compound && CG(current_import)) {
+	if (compound && CG(file_context).imports) {
 		/* If the first part of a qualified name is an alias, substitute it. */
 		size_t len = compound - name->val;
-		zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
+		zend_string *import_name = zend_hash_find_ptr_lc(CG(file_context).imports, name->val, len);
 
 		if (import_name) {
 			return zend_concat_names(
@@ -749,13 +795,13 @@ zend_string *zend_resolve_non_class_name(
 zend_string *zend_resolve_function_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified) /* {{{ */
 {
 	return zend_resolve_non_class_name(
-		name, type, is_fully_qualified, 0, CG(current_import_function));
+		name, type, is_fully_qualified, 0, CG(file_context).imports_function);
 }
 /* }}} */
 
 zend_string *zend_resolve_const_name(zend_string *name, uint32_t type, zend_bool *is_fully_qualified) /* {{{ */ {
 	return zend_resolve_non_class_name(
-		name, type, is_fully_qualified, 1, CG(current_import_const));
+		name, type, is_fully_qualified, 1, CG(file_context).imports_const);
 }
 /* }}} */
 
@@ -781,12 +827,13 @@ zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* {{{ */
 		return name;
 	}
 
-	if (CG(current_import)) {
+	if (CG(file_context).imports) {
 		compound = memchr(name->val, '\\', name->len);
 		if (compound) {
 			/* If the first part of a qualified name is an alias, substitute it. */
 			size_t len = compound - name->val;
-			zend_string *import_name = zend_hash_find_ptr_lc(CG(current_import), name->val, len);
+			zend_string *import_name =
+				zend_hash_find_ptr_lc(CG(file_context).imports, name->val, len);
 
 			if (import_name) {
 				return zend_concat_names(
@@ -795,7 +842,7 @@ zend_string *zend_resolve_class_name(zend_string *name, uint32_t type) /* {{{ */
 		} else {
 			/* If an unqualified name is an alias, replace it. */
 			zend_string *import_name
-				= zend_hash_find_ptr_lc(CG(current_import), name->val, name->len);
+				= zend_hash_find_ptr_lc(CG(file_context).imports, name->val, name->len);
 
 			if (import_name) {
 				return zend_string_copy(import_name);
@@ -881,21 +928,6 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2
 }
 /* }}} */
 
-void zend_release_labels(int temporary) /* {{{ */
-{
-	if (CG(context).labels) {
-		zend_hash_destroy(CG(context).labels);
-		FREE_HASHTABLE(CG(context).labels);
-		CG(context).labels = NULL;
-	}
-	if (!temporary && !zend_stack_is_empty(&CG(context_stack))) {
-		zend_compiler_context *ctx = zend_stack_top(&CG(context_stack));
-		CG(context) = *ctx;
-		zend_stack_del_top(&CG(context_stack));
-	}
-}
-/* }}} */
-
 static zend_bool zend_is_call(zend_ast *ast);
 
 static int generate_free_loop_var(znode *var) /* {{{ */
@@ -1621,28 +1653,6 @@ void zend_verify_namespace(void) /* {{{ */
 }
 /* }}} */
 
-static void zend_reset_import_tables(void) /* {{{ */
-{
-	if (CG(current_import)) {
-		zend_hash_destroy(CG(current_import));
-		efree(CG(current_import));
-		CG(current_import) = NULL;
-	}
-
-	if (CG(current_import_function)) {
-		zend_hash_destroy(CG(current_import_function));
-		efree(CG(current_import_function));
-		CG(current_import_function) = NULL;
-	}
-
-	if (CG(current_import_const)) {
-		zend_hash_destroy(CG(current_import_const));
-		efree(CG(current_import_const));
-		CG(current_import_const) = NULL;
-	}
-}
-/* }}} */
-
 static void zend_end_namespace(void) /* {{{ */ {
 	CG(in_namespace) = 0;
 	zend_reset_import_tables();
@@ -4503,8 +4513,8 @@ static void zend_begin_func_decl(znode *result, zend_op_array *op_array, zend_as
 
 	lcname = zend_string_tolower(name);
 
-	if (CG(current_import_function)) {
-		zend_string *import_name = zend_hash_find_ptr(CG(current_import_function), lcname);
+	if (CG(file_context).imports_function) {
+		zend_string *import_name = zend_hash_find_ptr(CG(file_context).imports_function, lcname);
 		if (import_name && !zend_string_equals_ci(lcname, import_name)) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare function %s "
 				"because the name is already in use", name->val);
@@ -4551,6 +4561,7 @@ void zend_compile_func_decl(znode *result, zend_ast *ast) /* {{{ */
 
 	zend_op_array *orig_op_array = CG(active_op_array);
 	zend_op_array *op_array = zend_arena_alloc(&CG(arena), sizeof(zend_op_array));
+	zend_oparray_context orig_oparray_context;
 
 	// TODO.AST interactive (not just here - also bpc etc!)
 
@@ -4575,8 +4586,7 @@ void zend_compile_func_decl(znode *result, zend_ast *ast) /* {{{ */
 	}
 
 	CG(active_op_array) = op_array;
-	zend_stack_push(&CG(context_stack), (void *) &CG(context));
-	zend_init_compiler_context();
+	zend_oparray_context_begin(&orig_oparray_context);
 
 	if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
 		zend_op *opline_ext = zend_emit_op(NULL, ZEND_EXT_NOP, NULL, NULL);
@@ -4606,7 +4616,7 @@ void zend_compile_func_decl(znode *result, zend_ast *ast) /* {{{ */
 	zend_emit_final_return(NULL);
 
 	pass_two(CG(active_op_array));
-	zend_release_labels(0);
+	zend_oparray_context_end(&orig_oparray_context);
 
 	/* Pop the loop variable stack separator */
 	zend_stack_del_top(&CG(loop_var_stack));
@@ -4884,8 +4894,8 @@ void zend_compile_class_decl(zend_ast *ast) /* {{{ */
 
 	lcname = zend_string_tolower(name);
 
-	if (CG(current_import)) {
-		import_name = zend_hash_find_ptr(CG(current_import), lcname);
+	if (CG(file_context).imports) {
+		import_name = zend_hash_find_ptr(CG(file_context).imports, lcname);
 	}
 
 	if (CG(current_namespace)) {
@@ -5036,25 +5046,26 @@ void zend_compile_class_decl(zend_ast *ast) /* {{{ */
 
 static HashTable *zend_get_import_ht(uint32_t type) /* {{{ */
 {
+	zend_file_context *ctx = &CG(file_context);
 	switch (type) {
 		case T_CLASS:
-			if (!CG(current_import)) {
-				CG(current_import) = emalloc(sizeof(HashTable));
-				zend_hash_init(CG(current_import), 8, NULL, str_dtor, 0);
+			if (!ctx->imports) {
+				ctx->imports = emalloc(sizeof(HashTable));
+				zend_hash_init(ctx->imports, 8, NULL, str_dtor, 0);
 			}
-			return CG(current_import);
+			return ctx->imports;
 		case T_FUNCTION:
-			if (!CG(current_import_function)) {
-				CG(current_import_function) = emalloc(sizeof(HashTable));
-				zend_hash_init(CG(current_import_function), 8, NULL, str_dtor, 0);
+			if (!ctx->imports_function) {
+				ctx->imports_function = emalloc(sizeof(HashTable));
+				zend_hash_init(ctx->imports_function, 8, NULL, str_dtor, 0);
 			}
-			return CG(current_import_function);
+			return ctx->imports_function;
 		case T_CONST:
-			if (!CG(current_import_const)) {
-				CG(current_import_const) = emalloc(sizeof(HashTable));
-				zend_hash_init(CG(current_import_const), 8, NULL, str_dtor, 0);
+			if (!ctx->imports_const) {
+				ctx->imports_const = emalloc(sizeof(HashTable));
+				zend_hash_init(ctx->imports_const, 8, NULL, str_dtor, 0);
 			}
-			return CG(current_import_const);
+			return ctx->imports_const;
 		EMPTY_SWITCH_DEFAULT_CASE()
 	}
 
@@ -5241,8 +5252,8 @@ void zend_compile_const_decl(zend_ast *ast) /* {{{ */
 		name = zend_prefix_with_ns(name);
 		name = zend_new_interned_string(name);
 
-		if (CG(current_import_const)
-			&& (import_name = zend_hash_find_ptr(CG(current_import_const), name))
+		if (CG(file_context).imports_const
+			&& (import_name = zend_hash_find_ptr(CG(file_context).imports_const, name))
 		) {
 			if (!zend_string_equals(import_name, name)) {
 				zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare const %s because "

Zend/zend_compile.h

@@ -53,18 +53,26 @@
 typedef struct _zend_op_array zend_op_array;
 typedef struct _zend_op zend_op;
 
-typedef struct _zend_compiler_context {
-	uint32_t  opcodes_size;
+/* Compilation context that is different for each op array. */
+typedef struct _zend_oparray_context {
+	uint32_t   opcodes_size;
 	int        vars_size;
 	int        literals_size;
 	int        current_brk_cont;
 	int        backpatch_count;
 	int        in_finally;
 	uint32_t   fast_call_var;
 	HashTable *labels;
-} zend_compiler_context;
+} zend_oparray_context;
 
-/* On 64-bi systems less optimal, but more compact VM code leads to better
+/* Compilation context that is different for each file, but shared between op arrays. */
+typedef struct _zend_file_context {
+	HashTable *imports;
+	HashTable *imports_function;
+	HashTable *imports_const;
+} zend_file_context;
+
+/* On 64-bit systems less optimal, but more compact VM code leads to better
  * performance. So on 32-bit systems we use absolute addresses for jump
  * targets and constants, but on 64-bit systems realtive 32-bit offsets */
 #if SIZEOF_SIZE_T == 4
@@ -637,7 +645,11 @@ BEGIN_EXTERN_C()
 void init_compiler(void);
 void shutdown_compiler(void);
 void zend_init_compiler_data_structures(void);
-void zend_init_compiler_context(void);
+
+void zend_oparray_context_begin(zend_oparray_context *prev_context);
+void zend_oparray_context_end(zend_oparray_context *prev_context);
+void zend_file_context_begin(zend_file_context *prev_context);
+void zend_file_context_end(zend_file_context *prev_context);
 
 extern ZEND_API zend_op_array *(*zend_compile_file)(zend_file_handle *file_handle, int type);
 extern ZEND_API zend_op_array *(*zend_compile_string)(zval *source_string, char *filename);
@@ -693,7 +705,6 @@ void zend_verify_namespace(void);
 void zend_do_end_compilation(void);
 
 void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2);
-void zend_release_labels(int temporary);
 
 ZEND_API void function_add_ref(zend_function *function);
 

Zend/zend_globals.h

@@ -113,16 +113,13 @@ struct _zend_compiler_globals {
 	uint32_t compiler_options; /* set of ZEND_COMPILE_* constants */
 
 	zend_string *current_namespace;
-	HashTable *current_import;
-	HashTable *current_import_function;
-	HashTable *current_import_const;
 	zend_bool  in_namespace;
 	zend_bool  has_bracketed_namespaces;
 
 	HashTable const_filenames;
 
-	zend_compiler_context context;
-	zend_stack context_stack;
+	zend_oparray_context context;
+	zend_file_context file_context;
 
 	zend_arena *arena;