Auto-generate cases in EXTENDED_ARG_3, and tweaks

Author: gvanrossum

Python/bytecodes.c

@@ -3346,11 +3346,10 @@ dummy_func(
             next_instr++;
             // oparg2 = _Py_OPCODE(*next_instr);  // Nothing uses it yet
             oparg3 = oparg3 << 8 | _Py_OPARG(*next_instr);
-            next_instr++;
+            frame->prev_instr = next_instr++;
             // Jump into the middle of that instruction
             switch (opcode) {
-                case MAKE_FUNCTION_FROM_CODE:
-                    goto into_make_function_from_code;
+                INSERT_EXTENDED_CASES();
                 default:
                     Py_FatalError("Unexpected opcode in EXTENDED_ARG_3");
                     while (1) { abort(); }

Python/generated_cases.c.h

@@ -215,8 +215,9 @@ class Instruction:
     family: parser.Family | None = None
     predicted: bool = False
 
-    def __init__(self, inst: parser.InstDef):
+    def __init__(self, inst: parser.InstDef, a: "Analyzer"):
         self.inst = inst
+        self.analyzer = a
         self.register = inst.register
         self.kind = inst.kind
         self.name = inst.name
@@ -278,7 +279,7 @@ def write(self, out: Formatter) -> None:
         """Write one instruction, sans prologue and epilogue."""
 
         # Write additional instruction decoding if > 1 word
-        if self.instr_fmt.startswith(("IBBB", "IBXB", "IBBX")):
+        if self.instr_fmt.startswith(("IBB", "IBX")):
             out.emit("// Decode rest of instruction")
             if self.instr_fmt[2] == "B":
                 out.emit("oparg2 = next_instr[0].opcode;")
@@ -288,7 +289,8 @@ def write(self, out: Formatter) -> None:
                 out.emit("oparg3 = next_instr[0].oparg;")
             else:
                 out.emit("// (oparg3 is unused)")
-            out.emit("next_instr++;")
+            # Update prev_instr, since it must equal next_instr - 1.
+            out.emit("frame->prev_instr = next_instr++;")
             with out.outdent():
                 # Need ';' because the next line may be a declaration.
                 # Declarations are not statements, only statements can have labels.
@@ -415,6 +417,13 @@ def write_body(self, out: Formatter, dedent: int, cache_adjust: int = 0) -> None
                     for ieff in self.input_effects:
                         if ieff.name not in self.unmoved_names:
                             out.write_raw(f"{extra}{space}Py_DECREF({ieff.name});\n")
+            elif m := re.match(r"(\s*)INSERT_EXTENDED_CASES\(\);\s*$", line):
+                assert self.name == "EXTENDED_ARG_3", self.name
+                space = m.group(1)
+                for instr in self.analyzer.instrs.values():
+                    if instr.instr_fmt.startswith(("IBB", "IBX")):
+                        out.write_raw(f"{extra}{space}case {instr.name}:\n")
+                        out.write_raw(f"{extra}{space}    goto into_{instr.name.lower()};\n")
             else:
                 out.write_raw(extra + line)
 
@@ -540,7 +549,7 @@ def parse(self) -> None:
         while thing := psr.definition():
             match thing:
                 case parser.InstDef(name=name):
-                    self.instrs[name] = Instruction(thing)
+                    self.instrs[name] = Instruction(thing, self)
                     self.everything.append(thing)
                 case parser.Super(name):
                     self.supers[name] = thing

Tools/cases_generator/generate_cases.py

@@ -446,10 +446,69 @@ def test_long_instr():
             // Decode rest of instruction
             oparg2 = next_instr[0].opcode;
             oparg3 = next_instr[0].oparg;
-            next_instr++;
+            frame->prev_instr = next_instr++;
         into_op:;  // For EXTENDED_ARG_3
             oparg, oparg2, oparg3;
             DISPATCH();
         }
     """
     run_cases_test(input, output)
+
+def test_extended_cases():
+    input = """
+        inst(OP, (--)) {
+            oparg;
+        }
+        inst(OP1, (--)) {
+            oparg, oparg2;
+        }
+        inst(OP2, (--)) {
+            oparg, oparg3;
+        }
+        inst(EXTENDED_ARG_3) {
+            switch (x) {
+                INSERT_EXTENDED_CASES();
+                default:
+                    abort();
+            }
+        }
+    """
+    output = """
+        TARGET(OP) {
+            oparg;
+            DISPATCH();
+        }
+
+        TARGET(OP1) {
+            // Decode rest of instruction
+            oparg2 = next_instr[0].opcode;
+            // (oparg3 is unused)
+            frame->prev_instr = next_instr++;
+        into_op1:;  // For EXTENDED_ARG_3
+            oparg, oparg2;
+            DISPATCH();
+        }
+
+        TARGET(OP2) {
+            // Decode rest of instruction
+            // (oparg2 is unused)
+            oparg3 = next_instr[0].oparg;
+            frame->prev_instr = next_instr++;
+        into_op2:;  // For EXTENDED_ARG_3
+            oparg, oparg3;
+            DISPATCH();
+        }
+
+        TARGET(EXTENDED_ARG_3) {
+            switch (x) {
+                case OP1:
+                    goto into_op1;
+                case OP2:
+                    goto into_op2;
+                default:
+                    abort();
+            }
+            DISPATCH();
+        }
+    """
+    run_cases_test(input, output)