Clean up the cases generator

Author: Fidget-Spinner

Python/generated_tracer_cases.c.h

@@ -107,9 +107,9 @@ class Emitter:
     labels: dict[str, Label]
     _replacers: dict[str, ReplacementFunctionType]
     cannot_escape: bool
-    tracing: str
+    jump_prefix: str
 
-    def __init__(self, out: CWriter, labels: dict[str, Label], cannot_escape: bool = False, is_tracing: bool = False):
+    def __init__(self, out: CWriter, labels: dict[str, Label], cannot_escape: bool = False, jump_prefix: str = ""):
         self._replacers = {
             "EXIT_IF": self.exit_if,
             "AT_END_EXIT_IF": self.exit_if_after,
@@ -133,7 +133,7 @@ def __init__(self, out: CWriter, labels: dict[str, Label], cannot_escape: bool =
         self.out = out
         self.labels = labels
         self.cannot_escape = cannot_escape
-        self.tracing = "TRACING_" if is_tracing else ""
+        self.jump_prefix = jump_prefix
 
     def dispatch(
         self,
@@ -170,7 +170,7 @@ def deopt_if(
         family_name = inst.family.name
         self.emit(f"UPDATE_MISS_STATS({family_name});\n")
         self.emit(f"assert(_PyOpcode_Deopt[opcode] == ({family_name}));\n")
-        self.emit(f"JUMP_TO_PREDICTED({family_name});\n")
+        self.emit(f"JUMP_TO_PREDICTED({self.jump_prefix}{family_name});\n")
         self.emit("}\n")
         return not always_true(first_tkn)
 
@@ -201,10 +201,10 @@ def exit_if_after(
 
     def goto_error(self, offset: int, storage: Storage) -> str:
         if offset > 0:
-            return f"{self.tracing}JUMP_TO_LABEL(pop_{offset}_error);"
+            return f"{self.jump_prefix}JUMP_TO_LABEL(pop_{offset}_error);"
         if offset < 0:
             storage.copy().flush(self.out)
-        return f"{self.tracing}JUMP_TO_LABEL(error);"
+        return f"{self.jump_prefix}JUMP_TO_LABEL(error);"
 
     def error_if(
         self,
@@ -424,7 +424,7 @@ def goto_label(self, goto: Token, label: Token, storage: Storage) -> None:
         elif storage.spilled:
             raise analysis_error("Cannot jump from spilled label without reloading the stack pointer", goto)
         self.out.start_line()
-        self.out.emit(f"{self.tracing}JUMP_TO_LABEL(")
+        self.out.emit(f"{self.jump_prefix}JUMP_TO_LABEL(")
         self.out.emit(label)
         self.out.emit(")")
 

Tools/cases_generator/generators_common.py

@@ -217,23 +217,20 @@ def get_popped(inst: Instruction, analysis: Analysis) -> str:
     return (-stack.base_offset).to_c()
 
 def generate_tier1_cases(
-    analysis: Analysis, out: CWriter, emitter: Emitter, is_tracing: bool = False
+    analysis: Analysis, out: CWriter, emitter: Emitter
 ) -> None:
-    tracing_prepend = "TRACING_" if is_tracing else ""
     out.emit("\n")
     for name, inst in sorted(analysis.instructions.items()):
         out.emit("\n")
-        out.emit(f"{tracing_prepend}TARGET({name}) {{\n")
-        if is_tracing:
-            out.emit(f"assert(IS_JIT_TRACING());\n")
+        out.emit(f"TARGET({name}) {{\n")
         popped = get_popped(inst, analysis)
         # We need to ifdef it because this breaks platforms
         # without computed gotos/tail calling.
         out.emit(f"#if _Py_TAIL_CALL_INTERP\n")
         out.emit(f"int opcode = {name};\n")
         out.emit(f"(void)(opcode);\n")
         out.emit(f"#endif\n")
-        needs_this = is_tracing or uses_this(inst)
+        needs_this = uses_this(inst)
         unused_guard = "(void)this_instr;\n"
         if inst.properties.needs_prev:
             out.emit(f"_Py_CODEUNIT* const prev_instr = frame->instr_ptr;\n")
@@ -247,21 +244,10 @@ def generate_tier1_cases(
         out.emit(f"next_instr += {inst.size};\n")
         out.emit(f"INSTRUCTION_STATS({name});\n")
         if inst.is_target:
-            out.emit(f"PREDICTED_{tracing_prepend}{name}:;\n")
+            out.emit(f"PREDICTED_{name}:;\n")
             if needs_this:
                 out.emit(f"_Py_CODEUNIT* const this_instr = next_instr - {inst.size};\n")
                 out.emit(unused_guard)
-        if is_tracing:
-            # This is required so that the predicted ops reflect the correct opcode.
-            out.emit(f"opcode = {name};\n")
-            out.emit(f"PyCodeObject *old_code = (PyCodeObject *)PyStackRef_AsPyObjectBorrow(frame->f_executable);\n")
-            out.emit(f"(void)old_code;\n")
-            out.emit(f"PyFunctionObject *old_func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);\n")
-            out.emit(f"(void)old_func;\n")
-            out.emit(f"int _jump_taken = false;\n")
-            out.emit(f"(void)_jump_taken;\n")
-            out.emit(f"int _old_stack_level = !PyStackRef_IsNull(frame->f_executable) ? STACK_LEVEL() : 0;\n")
-            out.emit(f"(void)(_old_stack_level);\n")
         if inst.properties.uses_opcode:
             out.emit(f"opcode = {name};\n")
         if inst.family is not None:
@@ -279,7 +265,7 @@ def generate_tier1_cases(
         out.start_line()
         if reachable: # type: ignore[possibly-undefined]
             stack.flush(out)
-            out.emit(f"{tracing_prepend}DISPATCH();\n")
+            out.emit(f"DISPATCH();\n")
         out.start_line()
         out.emit("}")
         out.emit("\n")

Tools/cases_generator/tier1_generator.py

@@ -28,7 +28,7 @@
 from typing import TextIO
 from lexer import Token
 from stack import Local, Stack, StackError, get_stack_effect, Storage
-from tier1_generator import generate_tier1_cases
+from tier1_generator import get_popped, declare_variables, write_uop
 
 DEFAULT_OUTPUT = ROOT / "Python/generated_tracer_cases.c.h"
 
@@ -39,7 +39,7 @@ class TracerEmitter(Emitter):
     cannot_escape: bool
 
     def __init__(self, out: CWriter, labels: dict[str, Label], cannot_escape: bool = False):
-        super().__init__(out, labels, cannot_escape, is_tracing=True)
+        super().__init__(out, labels, cannot_escape, jump_prefix="TRACING_")
         self._replacers = {
             **self._replacers,
             "DISPATCH": self.dispatch,
@@ -109,38 +109,71 @@ def record_dynamic_jump_taken(
         self.out.emit(";\n")
         return True
 
-    def deopt_if(
-        self,
-        tkn: Token,
-        tkn_iter: TokenIterator,
-        uop: CodeSection,
-        storage: Storage,
-        inst: Instruction | None,
-    ) -> bool:
-        self.out.start_line()
-        self.out.emit("if (")
-        lparen = next(tkn_iter)
-        assert lparen.kind == "LPAREN"
-        first_tkn = tkn_iter.peek()
-        emit_to(self.out, tkn_iter, "RPAREN")
-        self.emit(") {\n")
-        next(tkn_iter)  # Semi colon
-        assert inst is not None
-        assert inst.family is not None
-        family_name = inst.family.name
-        self.emit(f"UPDATE_MISS_STATS({family_name});\n")
-        self.emit(f"assert(_PyOpcode_Deopt[opcode] == ({family_name}));\n")
-        self.emit(f"JUMP_TO_PREDICTED(TRACING_{family_name});\n")
-        self.emit("}\n")
-        return not always_true(first_tkn)
-
-    exit_if = deopt_if
+def generate_tier1_tracer_cases(
+    analysis: Analysis, out: CWriter, emitter: Emitter
+) -> None:
+    out.emit("\n")
+    for name, inst in sorted(analysis.instructions.items()):
+        out.emit("\n")
+        out.emit(f"TRACING_TARGET({name}) {{\n")
+        out.emit(f"assert(IS_JIT_TRACING());\n")
+        # We need to ifdef it because this breaks platforms
+        # without computed gotos/tail calling.
+        out.emit(f"#if _Py_TAIL_CALL_INTERP\n")
+        out.emit(f"int opcode = {name};\n")
+        out.emit(f"(void)(opcode);\n")
+        out.emit(f"#endif\n")
+        unused_guard = "(void)this_instr;\n"
+        if inst.properties.needs_prev:
+            out.emit(f"_Py_CODEUNIT* const prev_instr = frame->instr_ptr;\n")
+        if not inst.is_target:
+            out.emit(f"_Py_CODEUNIT* const this_instr = next_instr;\n")
+            out.emit(unused_guard)
+        if not inst.properties.no_save_ip:
+            out.emit(f"frame->instr_ptr = next_instr;\n")
+
+        out.emit(f"next_instr += {inst.size};\n")
+        out.emit(f"INSTRUCTION_STATS({name});\n")
+        if inst.is_target:
+            out.emit(f"PREDICTED_TRACING_{name}:;\n")
+            out.emit(f"_Py_CODEUNIT* const this_instr = next_instr - {inst.size};\n")
+            out.emit(unused_guard)
+        # This is required so that the predicted ops reflect the correct opcode.
+        out.emit(f"opcode = {name};\n")
+        out.emit(f"PyCodeObject *old_code = (PyCodeObject *)PyStackRef_AsPyObjectBorrow(frame->f_executable);\n")
+        out.emit(f"(void)old_code;\n")
+        out.emit(f"PyFunctionObject *old_func = (PyFunctionObject *)PyStackRef_AsPyObjectBorrow(frame->f_funcobj);\n")
+        out.emit(f"(void)old_func;\n")
+        out.emit(f"int _jump_taken = false;\n")
+        out.emit(f"(void)_jump_taken;\n")
+        out.emit(f"int _old_stack_level = !PyStackRef_IsNull(frame->f_executable) ? STACK_LEVEL() : 0;\n")
+        out.emit(f"(void)(_old_stack_level);\n")
+        if inst.family is not None:
+            out.emit(
+                f"static_assert({inst.family.size} == {inst.size-1}"
+                ', "incorrect cache size");\n'
+            )
+        declare_variables(inst, out)
+        offset = 1  # The instruction itself
+        stack = Stack()
+        for part in inst.parts:
+            # Only emit braces if more than one uop
+            insert_braces = len([p for p in inst.parts if isinstance(p, Uop)]) > 1
+            reachable, offset, stack = write_uop(part, emitter, offset, stack, inst, insert_braces)
+        out.start_line()
+        if reachable: # type: ignore[possibly-undefined]
+            stack.flush(out)
+            out.emit(f"TRACING_DISPATCH();\n")
+        out.start_line()
+        out.emit("}")
+        out.emit("\n")
+
 
 def generate_tracer_cases(
     analysis: Analysis, out: CWriter
 ) -> None:
     out.emit(f"#ifdef _Py_TIER2 /* BEGIN TRACING INSTRUCTIONS */\n")
-    generate_tier1_cases(analysis, out, TracerEmitter(out, analysis.labels), is_tracing=True)
+    generate_tier1_tracer_cases(analysis, out, TracerEmitter(out, analysis.labels))
     out.emit(f"#endif /* END TRACING INSTRUCTIONS */\n")
 
 def generate_tracer(