Revert some unrelated changes

Include/internal/pycore_code.h

@@ -377,10 +377,10 @@ write_location_entry_start(uint8_t *ptr, int code, int length)
 #define ADAPTIVE_BACKOFF_BITS 4
 
 #define ADAPTIVE_BACKOFF_START_VALUE 1
-#define ADAPTIVE_BACKOFF_START_BACKOFF 1 // 2**0 <= 1 < 2**1
+#define ADAPTIVE_BACKOFF_START_BACKOFF 1
 
 #define ADAPTIVE_BACKOFF_RESTART_VALUE 52
-#define ADAPTIVE_BACKOFF_RESTART_BACKOFF 6 // 2**5 <= 53 < 2**6
+#define ADAPTIVE_BACKOFF_RESTART_BACKOFF 0
 
 #define MAX_BACKOFF_VALUE (16 - ADAPTIVE_BACKOFF_BITS)
 

Lib/opcode.py

@@ -319,6 +319,9 @@ def pseudo_op(name, op, real_ops):
         "COMPARE_OP_INT_JUMP",
         "COMPARE_OP_STR_JUMP",
     ],
+    "EXTENDED_ARG": [
+        "EXTENDED_ARG_QUICK",
+    ],
     "FOR_ITER": [
         "FOR_ITER_LIST",
         "FOR_ITER_RANGE",

Lib/test/test_embed.py

@@ -362,6 +362,8 @@ def is_specialized(f):
                         opname in opcode._specialized_instructions
                         # Exclude superinstructions:
                         and "__" not in opname
+                        # Exclude "quick" instructions:
+                        and not opname.endswith("_QUICK")
                     ):
                         return True
                 return False

Python/bytecodes.c

@@ -2268,7 +2268,17 @@ dummy_func(
         }
 
         inst(COMPARE_OP_GENERIC) {
-            goto compare_op;
+            assert(oparg <= Py_GE);
+            PyObject *right = POP();
+            PyObject *left = TOP();
+            PyObject *res = PyObject_RichCompare(left, right, oparg);
+            SET_TOP(res);
+            Py_DECREF(left);
+            Py_DECREF(right);
+            if (res == NULL) {
+                goto error;
+            }
+            JUMPBY(INLINE_CACHE_ENTRIES_COMPARE_OP);
         }
 
         // stack effect: (__0 -- )
@@ -2285,18 +2295,7 @@ dummy_func(
                 STAT_INC(COMPARE_OP, deferred);
                 DECREMENT_ADAPTIVE_COUNTER(cache);
             }
-        compare_op:
-            assert(oparg <= Py_GE);
-            PyObject *right = POP();
-            PyObject *left = TOP();
-            PyObject *res = PyObject_RichCompare(left, right, oparg);
-            SET_TOP(res);
-            Py_DECREF(left);
-            Py_DECREF(right);
-            if (res == NULL) {
-                goto error;
-            }
-            JUMPBY(INLINE_CACHE_ENTRIES_COMPARE_OP);
+            GO_TO_INSTRUCTION(COMPARE_OP_GENERIC);
         }
 
         // stack effect: (__0 -- )
@@ -3886,7 +3885,19 @@ dummy_func(
         }
 
         inst(BINARY_OP_GENERIC) {
-            goto binary_op;
+            PyObject *rhs = POP();
+            PyObject *lhs = TOP();
+            assert(0 <= oparg);
+            assert((unsigned)oparg < Py_ARRAY_LENGTH(binary_ops));
+            assert(binary_ops[oparg]);
+            PyObject *res = binary_ops[oparg](lhs, rhs);
+            Py_DECREF(lhs);
+            Py_DECREF(rhs);
+            SET_TOP(res);
+            if (res == NULL) {
+                goto error;
+            }
+            JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
         }
 
         // stack effect: (__0 -- )
@@ -3903,21 +3914,7 @@ dummy_func(
                 STAT_INC(BINARY_OP, deferred);
                 DECREMENT_ADAPTIVE_COUNTER(cache);
             }
-        binary_op:
-            ;  // Why is this still a thing in 2022?
-            PyObject *rhs = POP();
-            PyObject *lhs = TOP();
-            assert(0 <= oparg);
-            assert((unsigned)oparg < Py_ARRAY_LENGTH(binary_ops));
-            assert(binary_ops[oparg]);
-            PyObject *res = binary_ops[oparg](lhs, rhs);
-            Py_DECREF(lhs);
-            Py_DECREF(rhs);
-            SET_TOP(res);
-            if (res == NULL) {
-                goto error;
-            }
-            JUMPBY(INLINE_CACHE_ENTRIES_BINARY_OP);
+            GO_TO_INSTRUCTION(BINARY_OP_GENERIC);
         }
 
         // stack effect: ( -- )
@@ -3931,15 +3928,12 @@ dummy_func(
         // stack effect: ( -- )
         inst(EXTENDED_ARG) {
             assert(oparg);
-            opcode = _Py_OPCODE(*next_instr);
-            if (cframe.use_tracing) {
-                // Deoptimize the next opcode to avoid breaking tracing
-                // guarantees in quickened instructions:
-                opcode = _PyOpcode_Deopt[opcode];
-                PRE_DISPATCH_GOTO();
-            }
             oparg <<= 8;
             oparg |= _Py_OPARG(*next_instr);
+            // We might be tracing. To avoid breaking tracing guarantees in
+            // quickened instructions, always deoptimize the next opcode:
+            opcode = _PyOpcode_Deopt[_Py_OPCODE(*next_instr)];
+            PRE_DISPATCH_GOTO();
             // CPython hasn't traced the following instruction historically
             // (DO_TRACING would clobber our extended oparg anyways), so just
             // skip our usual cframe.use_tracing check before dispatch. Also,
@@ -3949,6 +3943,16 @@ dummy_func(
             DISPATCH_GOTO();
         }
 
+        // stack effect: ( -- )
+        inst(EXTENDED_ARG_QUICK) {
+            assert(cframe.use_tracing == 0);
+            assert(oparg);
+            int oldoparg = oparg;
+            NEXTOPARG();
+            oparg |= oldoparg << 8;
+            DISPATCH_GOTO();
+        }
+
         // stack effect: ( -- )
         inst(CACHE) {
             Py_UNREACHABLE();
@@ -3989,6 +3993,7 @@ family(call) = {
 family(compare_op) = {
     COMPARE_OP, COMPARE_OP_FLOAT_JUMP, COMPARE_OP_GENERIC,
     COMPARE_OP_INT_JUMP, COMPARE_OP_STR_JUMP };
+family(extended_arg) = { EXTENDED_ARG, EXTENDED_ARG_QUICK };
 family(for_iter) = {
     FOR_ITER, FOR_ITER_LIST,
     FOR_ITER_RANGE };

Python/compile.c

@@ -8062,6 +8062,7 @@ scan_block_for_locals(basicblock *b, basicblock ***sp)
     for (int i = 0; i < b->b_iused; i++) {
         struct instr *instr = &b->b_instr[i];
         assert(instr->i_opcode != EXTENDED_ARG);
+        assert(instr->i_opcode != EXTENDED_ARG_QUICK);
         assert(!IS_SUPERINSTRUCTION_OPCODE(instr->i_opcode));
         if (instr->i_except != NULL) {
             maybe_push(instr->i_except, unsafe_mask, sp);
@@ -8118,6 +8119,7 @@ fast_scan_many_locals(basicblock *entryblock, int nlocals)
         for (int i = 0; i < b->b_iused; i++) {
             struct instr *instr = &b->b_instr[i];
             assert(instr->i_opcode != EXTENDED_ARG);
+            assert(instr->i_opcode != EXTENDED_ARG_QUICK);
             assert(!IS_SUPERINSTRUCTION_OPCODE(instr->i_opcode));
             int arg = instr->i_oparg;
             if (arg < 64) {
@@ -8665,6 +8667,7 @@ fix_cell_offsets(struct compiler *c, basicblock *entryblock, int *fixedmap)
             struct instr *inst = &b->b_instr[i];
             // This is called before extended args are generated.
             assert(inst->i_opcode != EXTENDED_ARG);
+            assert(inst->i_opcode != EXTENDED_ARG_QUICK);
             int oldoffset = inst->i_oparg;
             switch(inst->i_opcode) {
                 case MAKE_CELL: