pythonGH-104610: Remove the use of PREDICT macros. (pythonGH-104651)

markshannon · web-flow · commit 064de0e3fca0 · 2023-06-07T17:04:53.000+01:00
diff --git a/Python/bytecodes.c b/Python/bytecodes.c
@@ -44,7 +44,6 @@
 #define DEOPT_IF(cond, instname) ((void)0)
 #define ERROR_IF(cond, labelname) ((void)0)
 #define GO_TO_INSTRUCTION(instname) ((void)0)
-#define PREDICT(opname) ((void)0)
 
 #define inst(name, ...) case name:
 #define op(name, ...) /* NAME is ignored */
@@ -562,14 +561,12 @@ dummy_func(
 
         inst(LIST_APPEND, (list, unused[oparg-1], v -- list, unused[oparg-1])) {
             ERROR_IF(_PyList_AppendTakeRef((PyListObject *)list, v) < 0, error);
-            PREDICT(JUMP_BACKWARD);
         }
 
         inst(SET_ADD, (set, unused[oparg-1], v -- set, unused[oparg-1])) {
             int err = PySet_Add(set, v);
             DECREF_INPUTS();
             ERROR_IF(err, error);
-            PREDICT(JUMP_BACKWARD);
         }
 
         family(store_subscr, INLINE_CACHE_ENTRIES_STORE_SUBSCR) = {
@@ -824,8 +821,6 @@ dummy_func(
                     Py_DECREF(next_iter);
                 }
             }
-
-            PREDICT(LOAD_CONST);
         }
 
         inst(GET_AWAITABLE, (iterable -- iter)) {
@@ -852,8 +847,6 @@ dummy_func(
             }
 
             ERROR_IF(iter == NULL, error);
-
-            PREDICT(LOAD_CONST);
         }
 
         family(send, INLINE_CACHE_ENTRIES_SEND) = {
@@ -1611,7 +1604,6 @@ dummy_func(
                 ERROR_IF(true, error);
             }
             DECREF_INPUTS();
-            PREDICT(CALL_FUNCTION_EX);
         }
 
         inst(MAP_ADD, (key, value --)) {
@@ -1620,7 +1612,6 @@ dummy_func(
             /* dict[key] = value */
             // Do not DECREF INPUTS because the function steals the references
             ERROR_IF(_PyDict_SetItem_Take2((PyDictObject *)dict, key, value) != 0, error);
-            PREDICT(JUMP_BACKWARD);
         }
 
         inst(INSTRUMENTED_LOAD_SUPER_ATTR, (unused/9, unused, unused, unused -- unused if (oparg & 1), unused)) {
@@ -2248,13 +2239,11 @@ dummy_func(
         inst(MATCH_MAPPING, (subject -- subject, res)) {
             int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING;
             res = match ? Py_True : Py_False;
-            PREDICT(POP_JUMP_IF_FALSE);
         }
 
         inst(MATCH_SEQUENCE, (subject -- subject, res)) {
             int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE;
             res = match ? Py_True : Py_False;
-            PREDICT(POP_JUMP_IF_FALSE);
         }
 
         inst(MATCH_KEYS, (subject, keys -- subject, keys, values_or_none)) {
@@ -2295,7 +2284,6 @@ dummy_func(
                 }
                 DECREF_INPUTS();
             }
-            PREDICT(LOAD_CONST);
         }
 
         // Most members of this family are "secretly" super-instructions.
@@ -2485,7 +2473,6 @@ dummy_func(
                 Py_DECREF(exit);
                 ERROR_IF(true, error);
             }
-            PREDICT(GET_AWAITABLE);
         }
 
         inst(BEFORE_WITH, (mgr -- exit, res)) {
diff --git a/Python/ceval_macros.h b/Python/ceval_macros.h
@@ -174,21 +174,6 @@ GETITEM(PyObject *v, Py_ssize_t i) {
 */
 
 #define PREDICT_ID(op)          PRED_##op
-
-#if USE_COMPUTED_GOTOS
-#define PREDICT(op)             if (0) goto PREDICT_ID(op)
-#else
-#define PREDICT(next_op) \
-    do { \
-        _Py_CODEUNIT word = *next_instr; \
-        opcode = word.op.code; \
-        if (opcode == next_op) { \
-            oparg = word.op.arg; \
-            INSTRUCTION_START(next_op); \
-            goto PREDICT_ID(next_op); \
-        } \
-    } while(0)
-#endif
 #define PREDICTED(op)           PREDICT_ID(op):
 
 
diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h

Original file line number	Diff line number	Diff line change
`@@ -44,7 +44,6 @@`
`44`	`44`	`#define DEOPT_IF(cond, instname) ((void)0)`
`45`	`45`	`#define ERROR_IF(cond, labelname) ((void)0)`
`46`	`46`	`#define GO_TO_INSTRUCTION(instname) ((void)0)`
`47`		`-#define PREDICT(opname) ((void)0)`
`48`	`47`
`49`	`48`	`#define inst(name, ...) case name:`
`50`	`49`	`#define op(name, ...) /* NAME is ignored */`
`@@ -562,14 +561,12 @@ dummy_func(`
`562`	`561`
`563`	`562`	`inst(LIST_APPEND, (list, unused[oparg-1], v -- list, unused[oparg-1])) {`
`564`	`563`	`ERROR_IF(_PyList_AppendTakeRef((PyListObject *)list, v) < 0, error);`
`565`		`- PREDICT(JUMP_BACKWARD);`
`566`	`564`	`}`
`567`	`565`
`568`	`566`	`inst(SET_ADD, (set, unused[oparg-1], v -- set, unused[oparg-1])) {`
`569`	`567`	`int err = PySet_Add(set, v);`
`570`	`568`	`DECREF_INPUTS();`
`571`	`569`	`ERROR_IF(err, error);`
`572`		`- PREDICT(JUMP_BACKWARD);`
`573`	`570`	`}`
`574`	`571`
`575`	`572`	`family(store_subscr, INLINE_CACHE_ENTRIES_STORE_SUBSCR) = {`
`@@ -824,8 +821,6 @@ dummy_func(`
`824`	`821`	`Py_DECREF(next_iter);`
`825`	`822`	`}`
`826`	`823`	`}`
`827`		`-`
`828`		`- PREDICT(LOAD_CONST);`
`829`	`824`	`}`
`830`	`825`
`831`	`826`	`inst(GET_AWAITABLE, (iterable -- iter)) {`
`@@ -852,8 +847,6 @@ dummy_func(`
`852`	`847`	`}`
`853`	`848`
`854`	`849`	`ERROR_IF(iter == NULL, error);`
`855`		`-`
`856`		`- PREDICT(LOAD_CONST);`
`857`	`850`	`}`
`858`	`851`
`859`	`852`	`family(send, INLINE_CACHE_ENTRIES_SEND) = {`
`@@ -1611,7 +1604,6 @@ dummy_func(`
`1611`	`1604`	`ERROR_IF(true, error);`
`1612`	`1605`	`}`
`1613`	`1606`	`DECREF_INPUTS();`
`1614`		`- PREDICT(CALL_FUNCTION_EX);`
`1615`	`1607`	`}`
`1616`	`1608`
`1617`	`1609`	`inst(MAP_ADD, (key, value --)) {`
`@@ -1620,7 +1612,6 @@ dummy_func(`
`1620`	`1612`	`/* dict[key] = value */`
`1621`	`1613`	`// Do not DECREF INPUTS because the function steals the references`
`1622`	`1614`	`ERROR_IF(_PyDict_SetItem_Take2((PyDictObject *)dict, key, value) != 0, error);`
`1623`		`- PREDICT(JUMP_BACKWARD);`
`1624`	`1615`	`}`
`1625`	`1616`
`1626`	`1617`	`inst(INSTRUMENTED_LOAD_SUPER_ATTR, (unused/9, unused, unused, unused -- unused if (oparg & 1), unused)) {`
`@@ -2248,13 +2239,11 @@ dummy_func(`
`2248`	`2239`	`inst(MATCH_MAPPING, (subject -- subject, res)) {`
`2249`	`2240`	`int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_MAPPING;`
`2250`	`2241`	`res = match ? Py_True : Py_False;`
`2251`		`- PREDICT(POP_JUMP_IF_FALSE);`
`2252`	`2242`	`}`
`2253`	`2243`
`2254`	`2244`	`inst(MATCH_SEQUENCE, (subject -- subject, res)) {`
`2255`	`2245`	`int match = Py_TYPE(subject)->tp_flags & Py_TPFLAGS_SEQUENCE;`
`2256`	`2246`	`res = match ? Py_True : Py_False;`
`2257`		`- PREDICT(POP_JUMP_IF_FALSE);`
`2258`	`2247`	`}`
`2259`	`2248`
`2260`	`2249`	`inst(MATCH_KEYS, (subject, keys -- subject, keys, values_or_none)) {`
`@@ -2295,7 +2284,6 @@ dummy_func(`
`2295`	`2284`	`}`
`2296`	`2285`	`DECREF_INPUTS();`
`2297`	`2286`	`}`
`2298`		`- PREDICT(LOAD_CONST);`
`2299`	`2287`	`}`
`2300`	`2288`
`2301`	`2289`	`// Most members of this family are "secretly" super-instructions.`
`@@ -2485,7 +2473,6 @@ dummy_func(`
`2485`	`2473`	`Py_DECREF(exit);`
`2486`	`2474`	`ERROR_IF(true, error);`
`2487`	`2475`	`}`
`2488`		`- PREDICT(GET_AWAITABLE);`
`2489`	`2476`	`}`
`2490`	`2477`
`2491`	`2478`	`inst(BEFORE_WITH, (mgr -- exit, res)) {`