Add 'out' parameter to stack.pop

Author: markshannon

Tools/cases_generator/cwriter.py

@@ -1,7 +1,7 @@
 import contextlib
 from lexer import Token
 from typing import TextIO, Iterator
-
+from io import StringIO
 
 class CWriter:
     "A writer that understands tokens and how to format C code"
@@ -18,6 +18,10 @@ def __init__(self, out: TextIO, indent: int, line_directives: bool):
         self.pending_spill = False
         self.pending_reload = False
 
+    @staticmethod
+    def null() -> "CWriter":
+        return CWriter(StringIO(), 0, False)
+
     def set_position(self, tkn: Token) -> None:
         if self.last_token is not None:
             if self.last_token.end_line < tkn.line:

Tools/cases_generator/optimizer_generator.py

@@ -72,8 +72,9 @@ def decref_inputs(
 
 
 def emit_default(out: CWriter, uop: Uop, stack: Stack) -> None:
+    null = CWriter.null()
     for var in reversed(uop.stack.inputs):
-        stack.pop(var)
+        stack.pop(var, null)
     offset = stack.base_offset - stack.physical_sp
     for var in uop.stack.outputs:
         if var.is_array() and not var.peek and not var.name == "unused":
@@ -123,9 +124,7 @@ def write_uop(
     try:
         out.start_line()
         if override:
-            code_list, storage = Storage.for_uop(stack, prototype, check_liveness=False)
-            for code in code_list:
-                out.emit(code)
+            storage = Storage.for_uop(stack, prototype, out, check_liveness=False)
         if debug:
             args = []
             for input in prototype.stack.inputs:

Tools/cases_generator/stack.py

@@ -229,7 +229,7 @@ def drop(self, var: StackItem, check_liveness: bool) -> None:
         if check_liveness:
             raise StackError(f"Dropping live value '{var.name}'")
 
-    def pop(self, var: StackItem) -> tuple[str, Local]:
+    def pop(self, var: StackItem, out: CWriter) -> Local:
         self.logical_sp = self.logical_sp.pop(var)
         indirect = "&" if var.is_array() else ""
         if self.variables:
@@ -244,9 +244,9 @@ def pop(self, var: StackItem) -> tuple[str, Local]:
                     f"Size mismatch when popping '{popped.name}' from stack to assign to '{var.name}'. "
                     f"Expected {var_size(var)} got {var_size(popped.item)}"
                 )
-                return "", popped
+                return popped
             if not var.used:
-                return "", popped
+                return popped
             if popped.name != var.name:
                 rename = f"{var.name} = {popped.name};\n"
                 popped.item = var
@@ -264,17 +264,18 @@ def pop(self, var: StackItem) -> tuple[str, Local]:
                     popped.in_local = True
             else:
                 defn = rename
-            return defn, popped
+            out.emit(defn)
+            return popped
 
         self.base_offset = self.logical_sp
         if var.name in UNUSED or not var.used:
-            return "", Local.unused(var, self.base_offset)
+            return Local.unused(var, self.base_offset)
         cast = f"({var.type})" if (not indirect and var.type) else ""
         bits = ".bits" if cast and self.extract_bits else ""
         offset = (self.base_offset - self.physical_sp).to_c()
-        assign = f"{var.name} = {cast}{indirect}stack_pointer[{offset}]{bits};"
-        assign = f"{assign}\n"
-        return assign, Local.from_memory(var, self.base_offset)
+        assign = f"{var.name} = {cast}{indirect}stack_pointer[{offset}]{bits};\n"
+        out.emit(assign)
+        return Local.from_memory(var, self.base_offset)
 
     def push(self, var: Local) -> None:
         assert(var not in self.variables)
@@ -391,8 +392,9 @@ def stacks(inst: Instruction | PseudoInstruction) -> Iterator[StackEffect]:
 
 def apply_stack_effect(stack: Stack, effect: StackEffect) -> None:
     locals: dict[str, Local] = {}
+    null = CWriter.null()
     for var in reversed(effect.inputs):
-        _, local = stack.pop(var)
+        local = stack.pop(var, null)
         if var.name != "unused":
             locals[local.name] = local
     for var in effect.outputs:
@@ -518,13 +520,11 @@ def reload(self, out: CWriter) -> None:
             out.emit_reload()
 
     @staticmethod
-    def for_uop(stack: Stack, uop: Uop, check_liveness: bool = True) -> tuple[list[str], "Storage"]:
-        code_list: list[str] = []
+    def for_uop(stack: Stack, uop: Uop, out: CWriter, check_liveness: bool = True) -> "Storage":
         inputs: list[Local] = []
         peeks: list[Local] = []
         for input in reversed(uop.stack.inputs):
-            code, local = stack.pop(input)
-            code_list.append(code)
+            local = stack.pop(input, out)
             if input.peek:
                 peeks.append(local)
             else:
@@ -537,12 +537,12 @@ def for_uop(stack: Stack, uop: Uop, check_liveness: bool = True) -> tuple[list[s
         for ouput in uop.stack.outputs:
             if ouput.is_array() and ouput.used and not ouput.peek:
                 c_offset = offset.to_c()
-                code_list.append(f"{ouput.name} = &stack_pointer[{c_offset}];\n")
+                out.emit(f"{ouput.name} = &stack_pointer[{c_offset}];\n")
             offset = offset.push(ouput)
         for var in inputs:
             stack.push(var)
         outputs = [ Local.undefined(var) for var in uop.stack.outputs if not var.peek ]
-        return code_list, Storage(stack, inputs, outputs, check_liveness)
+        return Storage(stack, inputs, outputs, check_liveness)
 
     @staticmethod
     def copy_list(arg: list[Local]) -> list[Local]:
@@ -716,5 +716,4 @@ def close_variable(var: Local, overwrite: str) -> None:
         if output_in_place:
             self.stack.flush(out)
         if output is not None:
-            code, output = self.stack.pop(output.item)
-            out.emit(code)
+            output = self.stack.pop(output.item, out)

Tools/cases_generator/tier1_generator.py

@@ -85,10 +85,8 @@ def write_uop(
         if braces:
             emitter.out.emit(f"// {uop.name}\n")
             emitter.emit("{\n")
-        code_list, storage = Storage.for_uop(stack, uop)
+        storage = Storage.for_uop(stack, uop, emitter.out)
         emitter._print_storage(storage)
-        for code in code_list:
-            emitter.emit(code)
 
         for cache in uop.caches:
             if cache.name != "unused":

Tools/cases_generator/tier2_generator.py

@@ -46,8 +46,9 @@ def declare_variable(
 
 def declare_variables(uop: Uop, out: CWriter) -> None:
     stack = Stack()
+    null = CWriter.null()
     for var in reversed(uop.stack.inputs):
-        stack.pop(var)
+        stack.pop(var, null)
     for var in uop.stack.outputs:
         stack.push(Local.undefined(var))
     seen = {"unused"}
@@ -142,9 +143,7 @@ def write_uop(uop: Uop, emitter: Emitter, stack: Stack) -> Stack:
         elif uop.properties.const_oparg >= 0:
             emitter.emit(f"oparg = {uop.properties.const_oparg};\n")
             emitter.emit(f"assert(oparg == CURRENT_OPARG());\n")
-        code_list, storage = Storage.for_uop(stack, uop)
-        for code in code_list:
-            emitter.emit(code)
+        storage = Storage.for_uop(stack, uop, emitter.out)
         idx = 0
         for cache in uop.caches:
             if cache.name != "unused":

Tools/cases_generator/uop_metadata_generator.py

@@ -47,13 +47,14 @@ def generate_names_and_flags(analysis: Analysis, out: CWriter) -> None:
     out.emit("};\n")
     out.emit("int _PyUop_num_popped(int opcode, int oparg)\n{\n")
     out.emit("switch(opcode) {\n")
+    null = CWriter.null()
     for uop in analysis.uops.values():
         if uop.is_viable() and uop.properties.tier != 1:
             stack = Stack()
             for var in reversed(uop.stack.inputs):
                 if var.peek:
                     break
-                stack.pop(var)
+                stack.pop(var, null)
             popped = (-stack.base_offset).to_c()
             out.emit(f"case {uop.name}:\n")
             out.emit(f"    return {popped};\n")