Refactor: Break dependenecy of metadata generation on Stack class

Author: markshannon

Python/generated_cases.c.h

@@ -4,13 +4,15 @@
 """
 
 import argparse
+from typing import Iterator
 
 from analyzer import (
     Analysis,
     Instruction,
     PseudoInstruction,
     analyze_files,
     Uop,
+    StackEffect
 )
 from generators_common import (
     DEFAULT_INPUT,
@@ -21,7 +23,7 @@
 from cwriter import CWriter
 from dataclasses import dataclass
 from typing import TextIO
-from stack import Stack, get_stack_effect, get_stack_effects
+from stack import StackOffset
 
 # Constants used instead of size for macro expansions.
 # Note: 1, 2, 4 must match actual cache entry sizes.
@@ -93,16 +95,55 @@ def emit_stack_effect_function(
     out.emit("#endif\n\n")
 
 
+def stacks(inst: Instruction | PseudoInstruction) -> Iterator[StackEffect]:
+    if isinstance(inst, Instruction):
+        for uop in inst.parts:
+            if isinstance(uop, Uop):
+                yield uop.stack
+    else:
+        assert isinstance(inst, PseudoInstruction)
+        yield inst.stack
+
+
+def apply_stack_effect(stack: StackOffset, effect: StackEffect) -> None:
+    for var in reversed(effect.inputs):
+        stack.pop(var)
+    for var in effect.outputs:
+        stack.push(var)
+
+
+def get_stack_effect(inst: Instruction | PseudoInstruction) -> StackOffset:
+    stack = StackOffset.empty()
+    for s in stacks(inst):
+        apply_stack_effect(stack, s)
+    return stack
+
+
+def get_stack_effects(inst: Instruction | PseudoInstruction) -> list[StackOffset]:
+    """Returns a list of stack effects after each uop"""
+    result = []
+    stack = StackOffset.empty()
+    for s in stacks(inst):
+        apply_stack_effect(stack, s)
+        result.append(stack.copy())
+    return result
+
 def generate_stack_effect_functions(analysis: Analysis, out: CWriter) -> None:
     popped_data: list[tuple[str, str]] = []
     pushed_data: list[tuple[str, str]] = []
 
     def add(inst: Instruction | PseudoInstruction) -> None:
-        stack = get_stack_effect(inst)
-        popped = (-stack.base_offset).to_c()
-        pushed = (stack.top_offset - stack.base_offset).to_c()
-        popped_data.append((inst.name, popped))
-        pushed_data.append((inst.name, pushed))
+        popped = StackOffset.empty()
+        stack = StackOffset.empty()
+        for effect in stacks(inst):
+            for var in reversed(effect.inputs):
+                stack.pop(var)
+            popped = popped.minimum(stack)
+            for var in effect.outputs:
+                stack.push(var)
+        pushed = stack - popped
+        popped_data.append((inst.name, (-popped).to_c()))
+        pushed_data.append((inst.name, pushed.to_c()))
 
     for inst in analysis.instructions.values():
         add(inst)
@@ -152,8 +193,7 @@ def __init__(self) -> None:
         self.int_effect = None
         self.cond_effects = set()
 
-    def add(self, stack: Stack) -> None:
-        top_off = stack.top_offset
+    def add(self, top_off: StackOffset) -> None:
         top_off_int = top_off.as_int()
         if top_off_int is not None:
             if self.int_effect is None or top_off_int > self.int_effect:

Tools/cases_generator/opcode_metadata_generator.py

@@ -134,6 +134,18 @@ def __sub__(self, other: "StackOffset") -> "StackOffset":
     def __neg__(self) -> "StackOffset":
         return StackOffset(self.pushed, self.popped)
 
+    def is_negative(self) -> bool:
+        self.simplify()
+        if not self.pushed:
+            return bool(self.popped)
+        return False
+
+    def is_non_negative(self) -> bool:
+        self.simplify()
+        if not self.popped:
+            return True
+        return False
+
     def simplify(self) -> None:
         "Remove matching values from both the popped and pushed list"
         if not self.popped:
@@ -164,6 +176,16 @@ def simplify(self) -> None:
         self.pushed.sort()
         self.popped.sort()
 
+    def minimum(self, other: "StackOffset") -> "StackOffset":
+        self.simplify()
+        other.simplify()
+        diff = self - other
+        if diff.is_non_negative():
+            return other.copy()
+        if diff.is_negative():
+            return self.copy()
+        raise StackError("Cannot determine minimum")
+
     def to_c(self) -> str:
         self.simplify()
         int_offset = 0
@@ -386,47 +408,6 @@ def merge(self, other: "Stack", out: CWriter) -> None:
         self.align(other, out)
 
 
-def stacks(inst: Instruction | PseudoInstruction) -> Iterator[StackEffect]:
-    if isinstance(inst, Instruction):
-        for uop in inst.parts:
-            if isinstance(uop, Uop):
-                yield uop.stack
-    else:
-        assert isinstance(inst, PseudoInstruction)
-        yield inst.stack
-
-
-def apply_stack_effect(stack: Stack, effect: StackEffect) -> None:
-    locals: dict[str, Local] = {}
-    for var in reversed(effect.inputs):
-        _, local = stack.pop(var)
-        if var.name != "unused":
-            locals[local.name] = local
-    for var in effect.outputs:
-        if var.name in locals:
-            local = locals[var.name]
-        else:
-            local = Local.unused(var)
-        stack.push(local)
-
-
-def get_stack_effect(inst: Instruction | PseudoInstruction) -> Stack:
-    stack = Stack()
-    for s in stacks(inst):
-        apply_stack_effect(stack, s)
-    return stack
-
-
-def get_stack_effects(inst: Instruction | PseudoInstruction) -> list[Stack]:
-    """Returns a list of stack effects after each uop"""
-    result = []
-    stack = Stack()
-    for s in stacks(inst):
-        apply_stack_effect(stack, s)
-        result.append(stack.copy())
-    return result
-
-
 @dataclass
 class Storage:
 

Tools/cases_generator/stack.py

@@ -25,7 +25,7 @@
 )
 from cwriter import CWriter
 from typing import TextIO, Callable
-from stack import Local, Stack, StackError, get_stack_effect, Storage
+from stack import Local, Stack, StackError, Storage
 
 DEFAULT_OUTPUT = ROOT / "Python/generated_cases.c.h"
 
@@ -47,22 +47,17 @@ def declare_variable(var: StackItem, out: CWriter) -> None:
 
 
 def declare_variables(inst: Instruction, out: CWriter) -> None:
-    try:
-        stack = get_stack_effect(inst)
-    except StackError as ex:
-        raise analysis_error(ex.args[0], inst.where) from None
-    required = set(stack.defined)
-    required.discard("unused")
+    declared = {"unused"}
     for part in inst.parts:
         if not isinstance(part, Uop):
             continue
         for var in part.stack.inputs:
-            if var.name in required:
-                required.remove(var.name)
+            if var.used and var.name not in declared:
+                declared.add(var.name)
                 declare_variable(var, out)
         for var in part.stack.outputs:
-            if var.name in required:
-                required.remove(var.name)
+            if var.used and var.name not in declared:
+                declared.add(var.name)
                 declare_variable(var, out)
 
 

Tools/cases_generator/tier1_generator.py

@@ -15,7 +15,7 @@
     write_header,
     cflags,
 )
-from stack import Stack
+from stack import StackOffset
 from cwriter import CWriter
 from typing import TextIO
 
@@ -49,12 +49,12 @@ def generate_names_and_flags(analysis: Analysis, out: CWriter) -> None:
     out.emit("switch(opcode) {\n")
     for uop in analysis.uops.values():
         if uop.is_viable() and uop.properties.tier != 1:
-            stack = Stack()
+            stack = StackOffset.empty()
             for var in reversed(uop.stack.inputs):
                 if var.peek:
                     break
                 stack.pop(var)
-            popped = (-stack.base_offset).to_c()
+            popped = (-stack).to_c()
             out.emit(f"case {uop.name}:\n")
             out.emit(f"    return {popped};\n")
     out.emit("default:\n")