bpo-46841: Add a _Py_SET_OPCODE macro (GH-31780)

diff --git a/Include/cpython/code.h b/Include/cpython/code.h
index f3e0761d953458a906bb40d26cfa3e353f365912..ab827c5ae87ffe3c1c049e63b5c407260164586d 100644 (file)
--- a/Include/cpython/code.h
+++ b/Include/cpython/code.h
@@ -23,6 +23,9 @@ typedef uint16_t _Py_CODEUNIT;
 #  define _Py_MAKECODEUNIT(opcode, oparg) ((opcode)|((oparg)<<8))
 #endif
 
+// Use "unsigned char" instead of "uint8_t" here to avoid illegal aliasing:
+#define _Py_SET_OPCODE(word, opcode) (((unsigned char *)&(word))[0] = (opcode))
+
 
 /* Bytecode object */
 struct PyCodeObject {

diff --git a/Python/ceval.c b/Python/ceval.c
index 83309e2c5219a79497a41da7cbf7c8c5c4eae814..f75147966421960172b4288806831cc6dd4a2a35 100644 (file)
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -5517,7 +5517,7 @@ opname ## _miss: \
         _Py_CODEUNIT *counter = (_Py_CODEUNIT *)next_instr; \
         *counter -= 1; \
         if (*counter == 0) { \
-            next_instr[-1] = _Py_MAKECODEUNIT(opname ## _ADAPTIVE, _Py_OPARG(next_instr[-1])); \
+            _Py_SET_OPCODE(next_instr[-1], opname ## _ADAPTIVE); \
             STAT_INC(opname, deopt); \
             *counter = ADAPTIVE_CACHE_BACKOFF; \
         } \

diff --git a/Python/specialize.c b/Python/specialize.c
index a11a76c4ef118b2fb0998c310a3b95d484c2da71..d84adac3520789d4eab17bf8271834d4421c58b8 100644 (file)
--- a/Python/specialize.c
+++ b/Python/specialize.c
@@ -294,59 +294,55 @@ static void
 optimize(_Py_CODEUNIT *instructions, int len)
 {
     int previous_opcode = -1;
-    int previous_oparg = -1;
     for(int i = 0; i < len; i++) {
         int opcode = _Py_OPCODE(instructions[i]);
-        int oparg = _Py_OPARG(instructions[i]);
         uint8_t adaptive_opcode = adaptive_opcodes[opcode];
         if (adaptive_opcode) {
-            instructions[i] = _Py_MAKECODEUNIT(adaptive_opcode, oparg);
+            _Py_SET_OPCODE(instructions[i], adaptive_opcode);
             // Make sure the adaptive counter is zero:
             assert(instructions[i + 1] == 0);
             previous_opcode = -1;
-            previous_oparg = -1;
             i += _PyOpcode_InlineCacheEntries[opcode];
         }
         else {
             assert(!_PyOpcode_InlineCacheEntries[opcode]);
             switch (opcode) {
                 case JUMP_ABSOLUTE:
-                    instructions[i] = _Py_MAKECODEUNIT(JUMP_ABSOLUTE_QUICK, oparg);
+                    _Py_SET_OPCODE(instructions[i], JUMP_ABSOLUTE_QUICK);
                     break;
                 case RESUME:
-                    instructions[i] = _Py_MAKECODEUNIT(RESUME_QUICK, oparg);
+                    _Py_SET_OPCODE(instructions[i], RESUME_QUICK);
                     break;
                 case LOAD_FAST:
                     switch(previous_opcode) {
                         case LOAD_FAST:
-                            assert(0 <= previous_oparg);
-                            instructions[i-1] = _Py_MAKECODEUNIT(LOAD_FAST__LOAD_FAST, previous_oparg);
+                            _Py_SET_OPCODE(instructions[i - 1],
+                                           LOAD_FAST__LOAD_FAST);
                             break;
                         case STORE_FAST:
-                            assert(0 <= previous_oparg);
-                            instructions[i-1] = _Py_MAKECODEUNIT(STORE_FAST__LOAD_FAST, previous_oparg);
+                            _Py_SET_OPCODE(instructions[i - 1],
+                                           STORE_FAST__LOAD_FAST);
                             break;
                         case LOAD_CONST:
-                            assert(0 <= previous_oparg);
-                            instructions[i-1] = _Py_MAKECODEUNIT(LOAD_CONST__LOAD_FAST, previous_oparg);
+                            _Py_SET_OPCODE(instructions[i - 1],
+                                           LOAD_CONST__LOAD_FAST);
                             break;
                     }
                     break;
                 case STORE_FAST:
                     if (previous_opcode == STORE_FAST) {
-                        assert(0 <= previous_oparg);
-                        instructions[i-1] = _Py_MAKECODEUNIT(STORE_FAST__STORE_FAST, previous_oparg);
+                        _Py_SET_OPCODE(instructions[i - 1],
+                                       STORE_FAST__STORE_FAST);
                     }
                     break;
                 case LOAD_CONST:
                     if (previous_opcode == LOAD_FAST) {
-                        assert(0 <= previous_oparg);
-                        instructions[i-1] = _Py_MAKECODEUNIT(LOAD_FAST__LOAD_CONST, previous_oparg);
+                        _Py_SET_OPCODE(instructions[i - 1],
+                                       LOAD_FAST__LOAD_CONST);
                     }
                     break;
             }
             previous_opcode = opcode;
-            previous_oparg = oparg;
         }
     }
 }
@@ -573,7 +569,7 @@ specialize_module_load_attr(PyObject *owner, _Py_CODEUNIT *instr,
     }
     write_u32(cache->version, keys_version);
     cache->index = (uint16_t)index;
-    *instr = _Py_MAKECODEUNIT(opcode_module, _Py_OPARG(*instr));
+    _Py_SET_OPCODE(*instr, opcode_module);
     return 0;
 }
 
@@ -684,7 +680,7 @@ specialize_dict_access(
         }
         write_u32(cache->version, type->tp_version_tag);
         cache->index = (uint16_t)index;
-        *instr = _Py_MAKECODEUNIT(values_op, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, values_op);
     }
     else {
         if (!PyDict_CheckExact(dict)) {
@@ -701,7 +697,7 @@ specialize_dict_access(
         }
         cache->index = (uint16_t)hint;
         write_u32(cache->version, type->tp_version_tag);
-        *instr = _Py_MAKECODEUNIT(hint_op, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, hint_op);
     }
     return 1;
 }
@@ -755,7 +751,7 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name)
             assert(offset > 0);
             cache->index = (uint16_t)offset;
             write_u32(cache->version, type->tp_version_tag);
-            *instr = _Py_MAKECODEUNIT(LOAD_ATTR_SLOT, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, LOAD_ATTR_SLOT);
             goto success;
         }
         case DUNDER_CLASS:
@@ -764,7 +760,7 @@ _Py_Specialize_LoadAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name)
             assert(offset == (uint16_t)offset);
             cache->index = (uint16_t)offset;
             write_u32(cache->version, type->tp_version_tag);
-            *instr = _Py_MAKECODEUNIT(LOAD_ATTR_SLOT, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, LOAD_ATTR_SLOT);
             goto success;
         }
         case OTHER_SLOT:
@@ -845,7 +841,7 @@ _Py_Specialize_StoreAttr(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name)
             assert(offset > 0);
             cache->index = (uint16_t)offset;
             write_u32(cache->version, type->tp_version_tag);
-            *instr = _Py_MAKECODEUNIT(STORE_ATTR_SLOT, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, STORE_ATTR_SLOT);
             goto success;
         }
         case DUNDER_CLASS:
@@ -938,7 +934,7 @@ specialize_class_load_method(PyObject *owner, _Py_CODEUNIT *instr,
         case NON_DESCRIPTOR:
             write_u32(cache->type_version, ((PyTypeObject *)owner)->tp_version_tag);
             write_obj(cache->descr, descr);
-            *instr = _Py_MAKECODEUNIT(LOAD_METHOD_CLASS, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, LOAD_METHOD_CLASS);
             return 0;
 #ifdef Py_STATS
         case ABSENT:
@@ -1052,19 +1048,19 @@ _Py_Specialize_LoadMethod(PyObject *owner, _Py_CODEUNIT *instr, PyObject *name)
     }
     switch(dictkind) {
         case NO_DICT:
-            *instr = _Py_MAKECODEUNIT(LOAD_METHOD_NO_DICT, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, LOAD_METHOD_NO_DICT);
             break;
         case MANAGED_VALUES:
-            *instr = _Py_MAKECODEUNIT(LOAD_METHOD_WITH_VALUES, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, LOAD_METHOD_WITH_VALUES);
             break;
         case MANAGED_DICT:
             *(int16_t *)&cache->dict_offset = (int16_t)MANAGED_DICT_OFFSET;
-            *instr = _Py_MAKECODEUNIT(LOAD_METHOD_WITH_DICT, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, LOAD_METHOD_WITH_DICT);
             break;
         case OFFSET_DICT:
             assert(owner_cls->tp_dictoffset > 0 && owner_cls->tp_dictoffset <= INT16_MAX);
             cache->dict_offset = (uint16_t)owner_cls->tp_dictoffset;
-            *instr = _Py_MAKECODEUNIT(LOAD_METHOD_WITH_DICT, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, LOAD_METHOD_WITH_DICT);
             break;
     }
     /* `descr` is borrowed. This is safe for methods (even inherited ones from
@@ -1130,7 +1126,7 @@ _Py_Specialize_LoadGlobal(
         }
         cache->index = (uint16_t)index;
         write_u32(cache->module_keys_version, keys_version);
-        *instr = _Py_MAKECODEUNIT(LOAD_GLOBAL_MODULE, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, LOAD_GLOBAL_MODULE);
         goto success;
     }
     if (!PyDict_CheckExact(builtins)) {
@@ -1166,7 +1162,7 @@ _Py_Specialize_LoadGlobal(
     cache->index = (uint16_t)index;
     write_u32(cache->module_keys_version, globals_version);
     cache->builtin_keys_version = (uint16_t)builtins_version;
-    *instr = _Py_MAKECODEUNIT(LOAD_GLOBAL_BUILTIN, _Py_OPARG(*instr));
+    _Py_SET_OPCODE(*instr, LOAD_GLOBAL_BUILTIN);
     goto success;
 fail:
     STAT_INC(LOAD_GLOBAL, failure);
@@ -1245,7 +1241,7 @@ _Py_Specialize_BinarySubscr(
     PyTypeObject *container_type = Py_TYPE(container);
     if (container_type == &PyList_Type) {
         if (PyLong_CheckExact(sub)) {
-            *instr = _Py_MAKECODEUNIT(BINARY_SUBSCR_LIST_INT, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, BINARY_SUBSCR_LIST_INT);
             goto success;
         }
         SPECIALIZATION_FAIL(BINARY_SUBSCR,
@@ -1254,7 +1250,7 @@ _Py_Specialize_BinarySubscr(
     }
     if (container_type == &PyTuple_Type) {
         if (PyLong_CheckExact(sub)) {
-            *instr = _Py_MAKECODEUNIT(BINARY_SUBSCR_TUPLE_INT, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, BINARY_SUBSCR_TUPLE_INT);
             goto success;
         }
         SPECIALIZATION_FAIL(BINARY_SUBSCR,
@@ -1262,7 +1258,7 @@ _Py_Specialize_BinarySubscr(
         goto fail;
     }
     if (container_type == &PyDict_Type) {
-        *instr = _Py_MAKECODEUNIT(BINARY_SUBSCR_DICT, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, BINARY_SUBSCR_DICT);
         goto success;
     }
     PyTypeObject *cls = Py_TYPE(container);
@@ -1292,7 +1288,7 @@ _Py_Specialize_BinarySubscr(
         }
         cache->func_version = version;
         ((PyHeapTypeObject *)container_type)->_spec_cache.getitem = descriptor;
-        *instr = _Py_MAKECODEUNIT(BINARY_SUBSCR_GETITEM, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, BINARY_SUBSCR_GETITEM);
         goto success;
     }
     SPECIALIZATION_FAIL(BINARY_SUBSCR,
@@ -1319,8 +1315,7 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
             if ((Py_SIZE(sub) == 0 || Py_SIZE(sub) == 1)
                 && ((PyLongObject *)sub)->ob_digit[0] < (size_t)PyList_GET_SIZE(container))
             {
-                *instr = _Py_MAKECODEUNIT(STORE_SUBSCR_LIST_INT,
-                                          _Py_OPARG(*instr));
+                _Py_SET_OPCODE(*instr, STORE_SUBSCR_LIST_INT);
                 goto success;
             }
             else {
@@ -1338,7 +1333,7 @@ _Py_Specialize_StoreSubscr(PyObject *container, PyObject *sub, _Py_CODEUNIT *ins
         }
     }
     if (container_type == &PyDict_Type) {
-        *instr = _Py_MAKECODEUNIT(STORE_SUBSCR_DICT, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, STORE_SUBSCR_DICT);
          goto success;
     }
 #ifdef Py_STATS
@@ -1427,20 +1422,20 @@ specialize_class_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
     if (tp->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) {
         if (nargs == 1 && kwnames == NULL && oparg == 1) {
             if (tp == &PyUnicode_Type) {
-                *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_STR_1, _Py_OPARG(*instr));
+                _Py_SET_OPCODE(*instr, PRECALL_NO_KW_STR_1);
                 return 0;
             }
             else if (tp == &PyType_Type) {
-                *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_TYPE_1, _Py_OPARG(*instr));
+                _Py_SET_OPCODE(*instr, PRECALL_NO_KW_TYPE_1);
                 return 0;
             }
             else if (tp == &PyTuple_Type) {
-                *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_TUPLE_1, _Py_OPARG(*instr));
+                _Py_SET_OPCODE(*instr, PRECALL_NO_KW_TUPLE_1);
                 return 0;
             }
         }
         if (tp->tp_vectorcall != NULL) {
-            *instr = _Py_MAKECODEUNIT(PRECALL_BUILTIN_CLASS, _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, PRECALL_BUILTIN_CLASS);
             return 0;
         }
         SPECIALIZATION_FAIL(PRECALL, tp == &PyUnicode_Type ?
@@ -1493,8 +1488,7 @@ specialize_method_descriptor(PyMethodDescrObject *descr, _Py_CODEUNIT *instr,
                 SPECIALIZATION_FAIL(PRECALL, SPEC_FAIL_WRONG_NUMBER_ARGUMENTS);
                 return -1;
             }
-            *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS,
-                _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, PRECALL_NO_KW_METHOD_DESCRIPTOR_NOARGS);
             return 0;
         }
         case METH_O: {
@@ -1505,17 +1499,14 @@ specialize_method_descriptor(PyMethodDescrObject *descr, _Py_CODEUNIT *instr,
             PyInterpreterState *interp = _PyInterpreterState_GET();
             PyObject *list_append = interp->callable_cache.list_append;
             if ((PyObject *)descr == list_append && oparg == 1) {
-                *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_LIST_APPEND,
-                                          _Py_OPARG(*instr));
+                _Py_SET_OPCODE(*instr, PRECALL_NO_KW_LIST_APPEND);
                 return 0;
             }
-            *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_METHOD_DESCRIPTOR_O,
-                _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, PRECALL_NO_KW_METHOD_DESCRIPTOR_O);
             return 0;
         }
         case METH_FASTCALL: {
-            *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST,
-                _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, PRECALL_NO_KW_METHOD_DESCRIPTOR_FAST);
             return 0;
         }
     }
@@ -1562,10 +1553,10 @@ specialize_py_call(PyFunctionObject *func, _Py_CODEUNIT *instr, int nargs,
     write_u32(cache->func_version, version);
     cache->min_args = min_args;
     if (argcount == nargs) {
-        *instr = _Py_MAKECODEUNIT(CALL_PY_EXACT_ARGS, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, CALL_PY_EXACT_ARGS);
     }
     else {
-        *instr = _Py_MAKECODEUNIT(CALL_PY_WITH_DEFAULTS, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, CALL_PY_WITH_DEFAULTS);
     }
     return 0;
 }
@@ -1593,12 +1584,10 @@ specialize_c_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
             /* len(o) */
             PyInterpreterState *interp = _PyInterpreterState_GET();
             if (callable == interp->callable_cache.len) {
-                *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_LEN,
-                    _Py_OPARG(*instr));
+                _Py_SET_OPCODE(*instr, PRECALL_NO_KW_LEN);
                 return 0;
             }
-            *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_BUILTIN_O,
-                _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, PRECALL_NO_KW_BUILTIN_O);
             return 0;
         }
         case METH_FASTCALL: {
@@ -1610,18 +1599,15 @@ specialize_c_call(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
                 /* isinstance(o1, o2) */
                 PyInterpreterState *interp = _PyInterpreterState_GET();
                 if (callable == interp->callable_cache.isinstance) {
-                    *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_ISINSTANCE,
-                        _Py_OPARG(*instr));
+                    _Py_SET_OPCODE(*instr, PRECALL_NO_KW_ISINSTANCE);
                     return 0;
                 }
             }
-            *instr = _Py_MAKECODEUNIT(PRECALL_NO_KW_BUILTIN_FAST,
-                _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, PRECALL_NO_KW_BUILTIN_FAST);
             return 0;
         }
         case METH_FASTCALL | METH_KEYWORDS: {
-            *instr = _Py_MAKECODEUNIT(PRECALL_BUILTIN_FAST_WITH_KEYWORDS,
-                _Py_OPARG(*instr));
+            _Py_SET_OPCODE(*instr, PRECALL_BUILTIN_FAST_WITH_KEYWORDS);
             return 0;
         }
         default:
@@ -1685,7 +1671,7 @@ _Py_Specialize_Precall(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
         fail = specialize_c_call(callable, instr, nargs, kwnames);
     }
     else if (PyFunction_Check(callable)) {
-        *instr = _Py_MAKECODEUNIT(PRECALL_PYFUNC, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, PRECALL_PYFUNC);
         fail = 0;
     }
     else if (PyType_Check(callable)) {
@@ -1696,7 +1682,7 @@ _Py_Specialize_Precall(PyObject *callable, _Py_CODEUNIT *instr, int nargs,
                                             instr, nargs, kwnames, oparg);
     }
     else if (Py_TYPE(callable) == &PyMethod_Type) {
-        *instr = _Py_MAKECODEUNIT(PRECALL_BOUND_METHOD, _Py_OPARG(*instr));
+        _Py_SET_OPCODE(*instr, PRECALL_BOUND_METHOD);
         fail = 0;
     }
     else {
@@ -1834,19 +1820,18 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
             if (PyUnicode_CheckExact(lhs)) {
                 _Py_CODEUNIT next = instr[INLINE_CACHE_ENTRIES_BINARY_OP + 1];
                 if (_Py_OPCODE(next) == STORE_FAST && Py_REFCNT(lhs) == 2) {
-                    *instr = _Py_MAKECODEUNIT(BINARY_OP_INPLACE_ADD_UNICODE,
-                                              oparg);
+                    _Py_SET_OPCODE(*instr, BINARY_OP_INPLACE_ADD_UNICODE);
                     goto success;
                 }
-                *instr = _Py_MAKECODEUNIT(BINARY_OP_ADD_UNICODE, oparg);
+                _Py_SET_OPCODE(*instr, BINARY_OP_ADD_UNICODE);
                 goto success;
             }
             if (PyLong_CheckExact(lhs)) {
-                *instr = _Py_MAKECODEUNIT(BINARY_OP_ADD_INT, oparg);
+                _Py_SET_OPCODE(*instr, BINARY_OP_ADD_INT);
                 goto success;
             }
             if (PyFloat_CheckExact(lhs)) {
-                *instr = _Py_MAKECODEUNIT(BINARY_OP_ADD_FLOAT, oparg);
+                _Py_SET_OPCODE(*instr, BINARY_OP_ADD_FLOAT);
                 goto success;
             }
             break;
@@ -1856,11 +1841,11 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
                 break;
             }
             if (PyLong_CheckExact(lhs)) {
-                *instr = _Py_MAKECODEUNIT(BINARY_OP_MULTIPLY_INT, oparg);
+                _Py_SET_OPCODE(*instr, BINARY_OP_MULTIPLY_INT);
                 goto success;
             }
             if (PyFloat_CheckExact(lhs)) {
-                *instr = _Py_MAKECODEUNIT(BINARY_OP_MULTIPLY_FLOAT, oparg);
+                _Py_SET_OPCODE(*instr, BINARY_OP_MULTIPLY_FLOAT);
                 goto success;
             }
             break;
@@ -1870,11 +1855,11 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
                 break;
             }
             if (PyLong_CheckExact(lhs)) {
-                *instr = _Py_MAKECODEUNIT(BINARY_OP_SUBTRACT_INT, oparg);
+                _Py_SET_OPCODE(*instr, BINARY_OP_SUBTRACT_INT);
                 goto success;
             }
             if (PyFloat_CheckExact(lhs)) {
-                *instr = _Py_MAKECODEUNIT(BINARY_OP_SUBTRACT_FLOAT, oparg);
+                _Py_SET_OPCODE(*instr, BINARY_OP_SUBTRACT_FLOAT);
                 goto success;
             }
             break;
@@ -1885,7 +1870,7 @@ _Py_Specialize_BinaryOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
             // back to BINARY_OP (unless we're collecting stats, where it's more
             // important to get accurate hit counts for the unadaptive version
             // and each of the different failure types):
-            *instr = _Py_MAKECODEUNIT(BINARY_OP, oparg);
+            _Py_SET_OPCODE(*instr, BINARY_OP);
             return;
 #endif
     }
@@ -1961,7 +1946,7 @@ _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
         // counts for the unadaptive version and each of the different failure
         // types):
 #ifndef Py_STATS
-        *instr = _Py_MAKECODEUNIT(COMPARE_OP, oparg);
+        _Py_SET_OPCODE(*instr, COMPARE_OP);
         return;
 #endif
         if (next_opcode == EXTENDED_ARG) {
@@ -1981,13 +1966,13 @@ _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
         goto failure;
     }
     if (PyFloat_CheckExact(lhs)) {
-        *instr = _Py_MAKECODEUNIT(COMPARE_OP_FLOAT_JUMP, oparg);
+        _Py_SET_OPCODE(*instr, COMPARE_OP_FLOAT_JUMP);
         cache->mask = when_to_jump_mask;
         goto success;
     }
     if (PyLong_CheckExact(lhs)) {
         if (Py_ABS(Py_SIZE(lhs)) <= 1 && Py_ABS(Py_SIZE(rhs)) <= 1) {
-            *instr = _Py_MAKECODEUNIT(COMPARE_OP_INT_JUMP, oparg);
+            _Py_SET_OPCODE(*instr, COMPARE_OP_INT_JUMP);
             cache->mask = when_to_jump_mask;
             goto success;
         }
@@ -2002,7 +1987,7 @@ _Py_Specialize_CompareOp(PyObject *lhs, PyObject *rhs, _Py_CODEUNIT *instr,
             goto failure;
         }
         else {
-            *instr = _Py_MAKECODEUNIT(COMPARE_OP_STR_JUMP, oparg);
+            _Py_SET_OPCODE(*instr, COMPARE_OP_STR_JUMP);
             cache->mask = (when_to_jump_mask & 2) == 0;
             goto success;
         }
@@ -2043,10 +2028,10 @@ _Py_Specialize_UnpackSequence(PyObject *seq, _Py_CODEUNIT *instr, int oparg)
             goto failure;
         }
         if (PyTuple_GET_SIZE(seq) == 2) {
-            *instr = _Py_MAKECODEUNIT(UNPACK_SEQUENCE_TWO_TUPLE, oparg);
+            _Py_SET_OPCODE(*instr, UNPACK_SEQUENCE_TWO_TUPLE);
             goto success;
         }
-        *instr = _Py_MAKECODEUNIT(UNPACK_SEQUENCE_TUPLE, oparg);
+        _Py_SET_OPCODE(*instr, UNPACK_SEQUENCE_TUPLE);
         goto success;
     }
     if (PyList_CheckExact(seq)) {
@@ -2054,7 +2039,7 @@ _Py_Specialize_UnpackSequence(PyObject *seq, _Py_CODEUNIT *instr, int oparg)
             SPECIALIZATION_FAIL(UNPACK_SEQUENCE, SPEC_FAIL_EXPECTED_ERROR);
             goto failure;
         }
-        *instr = _Py_MAKECODEUNIT(UNPACK_SEQUENCE_LIST, oparg);
+        _Py_SET_OPCODE(*instr, UNPACK_SEQUENCE_LIST);
         goto success;
     }
     SPECIALIZATION_FAIL(UNPACK_SEQUENCE, unpack_sequence_fail_kind(seq));