fix test_dis

Author: Fidget-Spinner

Lib/test/test_dis.py

@@ -880,9 +880,7 @@ def foo(x):
                RETURN_GENERATOR
                POP_TOP
        L1:     RESUME                   0
-               LOAD_FAST                0 (.0)
-               GET_ITER
-       L2:     FOR_ITER                16 (to L3)
+       L2:     FOR_ITER                15 (to L3)
                STORE_FAST               1 (z)
                LOAD_DEREF               2 (x)
                LOAD_FAST_BORROW         1 (z)
@@ -911,7 +909,7 @@ def load_test(x, y=0):
     return a, b
 
 dis_load_test_quickened_code = """\
-%3d           RESUME{: <6}             0
+%3d           RESUME_CHECK{: <6}       0
 
 %3d           LOAD_FAST_LOAD_FAST      1 (x, y)
               STORE_FAST_STORE_FAST   50 (b, a)
@@ -928,7 +926,7 @@ def loop_test():
         load_test(i)
 
 dis_loop_test_quickened_code = """\
-%3d           RESUME{: <6}             0
+%3d           RESUME_CHECK{: <6}       0
 
 %3d           BUILD_LIST               0
               LOAD_CONST               2 ((1, 2, 3))
@@ -1326,14 +1324,14 @@ def test_super_instructions(self):
         self.code_quicken(lambda: load_test(0, 0))
         got = self.get_disassembly(load_test, adaptive=True)
         jit = sys._jit.is_enabled()
-        expected = dis_load_test_quickened_code.format("" if jit else "_CHECK")
+        expected = dis_load_test_quickened_code.format("_JIT" if jit else "")
         self.do_disassembly_compare(got, expected)
 
     @cpython_only
     @requires_specialization
     def test_load_attr_specialize(self):
         load_attr_quicken = """\
-  0           RESUME{: <6}             0
+  0           RESUME_CHECK{: <6}       0
 
   1           LOAD_CONST               0 ('a')
               LOAD_ATTR_SLOT           0 (__class__)
@@ -1343,14 +1341,14 @@ def test_load_attr_specialize(self):
         self.code_quicken(lambda: exec(co, {}, {}))
         got = self.get_disassembly(co, adaptive=True)
         jit = sys._jit.is_enabled()
-        expected = load_attr_quicken.format("" if jit else "_CHECK")
+        expected = load_attr_quicken.format("_JIT" if jit else "")
         self.do_disassembly_compare(got, expected)
 
     @cpython_only
     @requires_specialization
     def test_call_specialize(self):
         call_quicken = """\
-  0           RESUME{: <6}             0
+  0           RESUME_CHECK{: <6}       0
 
   1           LOAD_NAME                0 (str)
               PUSH_NULL
@@ -1362,7 +1360,7 @@ def test_call_specialize(self):
         self.code_quicken(lambda: exec(co, {}, {}))
         got = self.get_disassembly(co, adaptive=True)
         jit = sys._jit.is_enabled()
-        expected = call_quicken.format("" if jit else "_CHECK")
+        expected = call_quicken.format("_JIT" if jit else "")
         self.do_disassembly_compare(got, expected)
 
     @cpython_only
@@ -1372,7 +1370,7 @@ def test_loop_quicken(self):
         self.code_quicken(loop_test)
         got = self.get_disassembly(loop_test, adaptive=True)
         jit = sys._jit.is_enabled()
-        resume_str = "" if jit else "_CHECK"
+        resume_str = "_JIT" if jit else ""
         jit_str = "_JIT" if jit else "NO_JIT"
         expected = dis_loop_test_quickened_code.format(resume_str, jit_str)
         self.do_disassembly_compare(got, expected)

Modules/_testinternalcapi.c

@@ -3023,9 +3023,10 @@ module_exec(PyObject *module)
         return 1;
     }
 
+    long resume_threshold = interp->opt_config.resume_initial_value + 1;
     if (PyModule_Add(module, "TIER2_RESUME_THRESHOLD",
         // + 1 more due to one loop spent on tracing.
-                    PyLong_FromLong(RESUME_INITIAL_VALUE + 2)) < 0) {
+                    PyLong_FromLong(resume_threshold)) < 0) {
         return 1;
     }
 

Python/specialize.c

@@ -73,11 +73,9 @@ _PyCode_Quicken(_Py_CODEUNIT *instructions, Py_ssize_t size, int enable_counters
                 case JUMP_BACKWARD:
                     instructions[i + 1].counter = jump_counter;
                     break;
-            #ifdef _Py_TIER2
                 case RESUME:
                     instructions[i + 1].counter = resume_counter;
                     break;
-            #endif
                 case POP_JUMP_IF_FALSE:
                 case POP_JUMP_IF_TRUE:
                 case POP_JUMP_IF_NONE: