Remove 'outputs' from Stack

Author: colesbury

Tools/cases_generator/analyzer.py

@@ -370,7 +370,7 @@ def find_assignment_target(idx: int) -> list[lexer.Token]:
         if tkn.kind != "IDENTIFIER" or tkn.text != "PyStackRef_FromPyObjectNew":
             continue
 
-        if node.block.tokens[idx-1].kind != "EQUALS":
+        if idx == 0 or node.block.tokens[idx-1].kind != "EQUALS":
             raise analysis_error("Expected '=' before PyStackRef_FromPyObjectNew", tkn)
 
         lhs = find_assignment_target(idx)

Tools/cases_generator/generators_common.py

@@ -225,7 +225,7 @@ def py_stack_ref_from_py_object_new(
         # Flush the assignment to the stack.  Note that we don't flush the
         # stack pointer here, and instead are currently relying on initializing
         # unused portions of the stack to NULL.
-        stack.flush_single_var(self.out, target)
+        stack.flush_single_var(self.out, target, uop.stack.outputs)
 
 
     def emit_tokens(

Tools/cases_generator/optimizer_generator.py

@@ -112,14 +112,7 @@ def write_uop(
                 out.emit(code)
             if local.defined:
                 locals[local.name] = local
-        outputs: list[Local] = []
-        for var in prototype.stack.outputs:
-            if var.name in locals:
-                local = locals[var.name]
-            else:
-                local = Local.local(var)
-            outputs.append(local)
-        out.emit(stack.define_outputs(outputs))
+        out.emit(stack.define_output_arrays(prototype.stack.outputs))
         if debug:
             args = []
             for var in prototype.stack.inputs:
@@ -141,7 +134,12 @@ def write_uop(
         else:
             emit_default(out, uop)
 
-        out.emit(stack.push_outputs())
+        for var in prototype.stack.outputs:
+            if var.name in locals:
+                local = locals[var.name]
+            else:
+                local = Local.local(var)
+            out.emit(stack.push(local))
         out.start_line()
         stack.flush(out, cast_type="_Py_UopsSymbol *", extract_bits=True)
     except StackError as ex:

Tools/cases_generator/stack.py

@@ -169,7 +169,6 @@ def __init__(self) -> None:
         self.top_offset = StackOffset.empty()
         self.base_offset = StackOffset.empty()
         self.variables: list[Local] = []
-        self.outputs: list[Local] = []
         self.defined: set[str] = set()
 
     def pop(self, var: StackItem, extract_bits: bool = False) -> tuple[str, Local]:
@@ -245,28 +244,22 @@ def push(self, var: Local) -> str:
                 self.defined.add(var.name)
             return ""
 
-    def define_outputs(self, outputs: list[Local]) -> str:
+    def define_output_arrays(self, outputs: list[StackItem]) -> str:
         res = []
         top_offset = self.top_offset.copy()
         for var in outputs:
-            if var.is_array() and var.item.used and not var.item.peek:
+            if var.is_array() and var.used and not var.peek:
                 c_offset = top_offset.to_c()
+                top_offset.push(var)
                 res.append(f"{var.name} = &stack_pointer[{c_offset}];\n")
-            self.outputs.append(var)
-            top_offset.push(var.item)
+            else:
+                top_offset.push(var)
         return "\n".join(res)
 
-    def push_outputs(self) -> str:
-        res = []
-        for var in self.outputs:
-            res.append(self.push(var))
-        self.outputs = []
-        return "".join(res)
-
     @staticmethod
-    def _do_emit(out: CWriter, var: Local, base_offset: StackOffset,
+    def _do_emit(out: CWriter, var: StackItem, base_offset: StackOffset,
                  cast_type: str = "uintptr_t", extract_bits: bool = False) -> None:
-        cast = f"({cast_type})" if var.item.type else ""
+        cast = f"({cast_type})" if var.type else ""
         bits = ".bits" if cast and not extract_bits else ""
         if var.condition == "0":
             return
@@ -282,7 +275,7 @@ def _do_flush(out: CWriter, variables: list[Local], base_offset: StackOffset, to
         out.start_line()
         for var in variables:
             if var.cached and not var.in_memory and not var.item.peek and not var.name in UNUSED:
-                Stack._do_emit(out, var, base_offset, cast_type, extract_bits)
+                Stack._do_emit(out, var.item, base_offset, cast_type, extract_bits)
             base_offset.push(var.item)
         if base_offset.to_c() != top_offset.to_c():
             print("base", base_offset, "top", top_offset)
@@ -302,18 +295,22 @@ def flush(self, out: CWriter, cast_type: str = "uintptr_t", extract_bits: bool =
         self.base_offset.clear()
         self.top_offset.clear()
 
-    def flush_single_var(self, out: CWriter, var_name: str, cast_type: str = "uintptr_t", extract_bits: bool = False) -> None:
-        assert any(var.name == var_name for var in self.outputs)
+    def flush_single_var(self, out: CWriter, var_name: str, outputs: list[StackItem],
+                         cast_type: str = "uintptr_t", extract_bits: bool = False) -> None:
+        assert any(var.name == var_name for var in outputs)
         base_offset = self.base_offset.copy()
         top_offset = self.top_offset.copy()
         for var in self.variables:
-            base_offset.push(var.item)
-        for var in self.outputs:
+            base_offset.push(var)
+        for var in outputs:
+            if any(var == v.item for v in self.variables):
+                # The variable is already on the stack, such as a peeked value
+                # in the tier1 generator
+                continue
             if var.name == var_name:
-                var.cached = False
                 Stack._do_emit(out, var, base_offset, cast_type, extract_bits)
-            base_offset.push(var.item)
-            top_offset.push(var.item)
+            base_offset.push(var)
+            top_offset.push(var)
         if base_offset.to_c() != top_offset.to_c():
             print("base", base_offset, "top", top_offset)
             assert False

Tools/cases_generator/tier1_generator.py

@@ -92,6 +92,7 @@ def write_uop(
             stack.push(peeks.pop())
         if braces:
             emitter.emit("{\n")
+        emitter.out.emit(stack.define_output_arrays(uop.stack.outputs))
         outputs: list[Local] = []
         for var in uop.stack.outputs:
             if not var.peek:
@@ -102,7 +103,6 @@ def write_uop(
                 else:
                     local = Local.local(var)
                 outputs.append(local)
-        emitter.emit(stack.define_outputs(outputs))
 
         for cache in uop.caches:
             if cache.name != "unused":
@@ -119,7 +119,11 @@ def write_uop(
                     emitter.emit(f"(void){cache.name};\n")
             offset += cache.size
         emitter.emit_tokens(uop, stack, inst)
-        emitter.emit(stack.push_outputs())
+        for var in outputs:
+            if var.name in uop.deferred_refs.values():
+                # We've already spilled this when emitting tokens
+                var.cached = False
+            emitter.emit(stack.push(var))
         if braces:
             emitter.out.start_line()
             emitter.emit("}\n")

Tools/cases_generator/tier2_generator.py

@@ -165,14 +165,14 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None:
             emitter.emit(code)
             if local.defined:
                 locals[local.name] = local
+        emitter.emit(stack.define_output_arrays(uop.stack.outputs))
         outputs: list[Local] = []
         for var in uop.stack.outputs:
             if var.name in locals:
                 local = locals[var.name]
             else:
                 local = Local.local(var)
             outputs.append(local)
-        emitter.emit(stack.define_outputs(outputs))
         for cache in uop.caches:
             if cache.name != "unused":
                 if cache.size == 4:
@@ -182,7 +182,11 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> None:
                     cast = f"uint{cache.size*16}_t"
                 emitter.emit(f"{type}{cache.name} = ({cast})CURRENT_OPERAND();\n")
         emitter.emit_tokens(uop, stack, None)
-        emitter.emit(stack.push_outputs())
+        for var in outputs:
+            if var.name in uop.deferred_refs.values():
+                # We've already spilled this when emitting tokens
+                var.cached = False
+            emitter.emit(stack.push(var))
     except StackError as ex:
         raise analysis_error(ex.args[0], uop.body[0]) from None