gh-148285: Allow recording uops after specializing uops in cases_generator

Author: adityakrmishra

Tools/cases_generator/analyzer.py

@@ -1132,26 +1132,42 @@ def add_macro(
     macro: parser.Macro, instructions: dict[str, Instruction], uops: dict[str, Uop]
 ) -> None:
     parts: list[Part] = []
-    first = True
+    # True when the next uop is allowed to be a recording uop.
+    # Starts True (position 0 is always valid), stays True after a
+    # specializing (tier-1) uop because specializing uops only exist in
+    # Tier 1 and recording uops only exist in Tier 2 — they are orthogonal
+    # at runtime, so no conflict arises from that ordering.
+    valid_recording_pos = True
     for part in macro.uops:
         match part:
             case parser.OpName():
                 if part.name == "flush":
                     parts.append(Flush())
+                    # A flush does not alter the recording-position state;
+                    # treat it as transparent.
                 else:
                     if part.name not in uops:
                         raise analysis_error(
                             f"No Uop named {part.name}", macro.tokens[0]
                         )
                     uop = uops[part.name]
-                    if uop.properties.records_value and not first:
+                    if uop.properties.records_value and not valid_recording_pos:
                         raise analysis_error(
-                            f"Recording uop {part.name} must be first in macro",
+                            f"Recording uop {part.name} must be first in macro "
+                            f"or immediately follow a specializing uop",
                             macro.tokens[0])
                     parts.append(uop)
-                    first = False
+                    # A specializing uop (tier == 1) keeps the gate open so
+                    # that a recording uop may follow it.  Any other concrete
+                    # uop closes the gate.
+                    if uop.properties.tier == 1:
+                        valid_recording_pos = True
+                    else:
+                        valid_recording_pos = False
             case parser.CacheEffect():
                 parts.append(Skip(part.size))
+                # Cache-entry skips are transparent to the recording-position
+                # state (they carry no runtime semantics).
             case _:
                 assert False
     assert parts