Reset deoptmap and fix test_dis

python · markshannon · Apr 19, 2022 · Mar 23, 2022 · Mar 24, 2022 · Mar 24, 2022
commit ceabedbe42823becee2326be86fe56fc151865f4
diff --git a/Lib/dis.py b/Lib/dis.py
@@ -33,6 +33,10 @@
 
 CACHE = opmap["CACHE"]
 
+def deoptop(op):
+    name = opname[op]
+    return opmap[deoptmap[name]] if name in deoptmap else opmap[name]
+
 def _try_compile(source, name):
     """Attempts to compile the given source, first as an expression and
        then as a statement if the first approach fails.
@@ -428,40 +432,43 @@ def _get_instructions_bytes(code, varname_from_oparg=None,
             #  available, and argrepr to the string representation of argval.
             #    _disassemble_bytes needs the string repr of the
             #    raw name index for LOAD_GLOBAL, LOAD_CONST, etc.
+            deop = deoptop(op)
             argval = arg
-            if op in hasconst:
-                argval, argrepr = _get_const_info(op, arg, co_consts)
-            elif op in hasname:
-                if op == LOAD_GLOBAL:
+            if deop in hasconst:
+                argval, argrepr = _get_const_info(deop, arg, co_consts)
+            elif deop in hasname:
+                if deop == LOAD_GLOBAL:
                     argval, argrepr = _get_name_info(arg//2, get_name)
                     if (arg & 1) and argrepr:
                         argrepr = "NULL + " + argrepr
                 else:
                     argval, argrepr = _get_name_info(arg, get_name)
-            elif op in hasjabs:
+            elif deop in hasjabs:
                 argval = arg*2
                 argrepr = "to " + repr(argval)
-            elif op in hasjrel:
+            elif deop in hasjrel:
                 argval = offset + 2 + arg*2
                 argrepr = "to " + repr(argval)
-            elif op in haslocal or op in hasfree:
+            elif deop in haslocal or deop in hasfree:
                 argval, argrepr = _get_name_info(arg, varname_from_oparg)
-            elif op in hascompare:
+            elif deop in hascompare:
                 argval = cmp_op[arg]
                 argrepr = argval
-            elif op == FORMAT_VALUE:
+            elif deop == FORMAT_VALUE:
                 argval, argrepr = FORMAT_VALUE_CONVERTERS[arg & 0x3]
                 argval = (argval, bool(arg & 0x4))
                 if argval[1]:
                     if argrepr:
                         argrepr += ', '
                     argrepr += 'with format'
-            elif op == MAKE_FUNCTION:
+            elif deop == MAKE_FUNCTION:
                 argrepr = ', '.join(s for i, s in enumerate(MAKE_FUNCTION_FLAGS)
                                     if arg & (1<<i))
-            elif op == BINARY_OP:
+            elif deop == BINARY_OP:
                 _, argrepr = _nb_ops[arg]
-        name = opname[deoptmap[op]] if not quickened and op in deoptmap else opname[op]
+        name = opname[op]
+        if not quickened and name in deoptmap:
+            name = deoptmap[name]
         yield Instruction(name, op,
                           arg, argval, argrepr,
                           offset, starts_line, is_jump_target, positions)
@@ -546,8 +553,7 @@ def _unpack_opargs(code):
     extended_arg = 0
     for i in range(0, len(code), 2):
         op = code[i]
-        oop = op if op not in deoptmap else deoptmap[op]
-        if oop >= HAVE_ARGUMENT:
+        if deoptop(op) >= HAVE_ARGUMENT:
             arg = code[i+1] | extended_arg
             extended_arg = (arg << 8) if op == EXTENDED_ARG else 0
             # The oparg is stored as a signed integer

diff --git a/Lib/opcode.py b/Lib/opcode.py
@@ -34,16 +34,13 @@
 
 opmap = {}
 opname = ['<%r>' % (op,) for op in range(256)]
-deoptmap = {}
 
 _inline_cache_entries = [0] * 256
-_empty_slot = [i for i in range(256)]
 
 def def_op(name, op, entries=0):
     opname[op] = name
     opmap[name] = op
     _inline_cache_entries[op] = entries
-    _empty_slot[op] = False
 
 def name_op(name, op, entries=0):
     def_op(name, op, entries)
@@ -344,12 +341,15 @@ def spec_op(origin_name, spec_name, counter):
     opcode for family in _specializations.values() for opcode in family
 ]
 
-_empty_slot = [i for i in filter(lambda e: e is not False, _empty_slot)]
-_specialized_counter = 0
-for basic, family in _specializations.items():
-    for specialized in family:
-        spec_op(basic, specialized, _specialized_counter)
-        _specialized_counter += 1
+_empty_slot = [slot for slot, name in enumerate(opname) if name.startswith("<")]
+for spec_op, specialized in zip(_empty_slot, _specialized_instructions):
+    # fill opname and opmap
+    opname[spec_op] = specialized
+    opmap[specialized] = spec_op
+
+deoptmap = {
+    specialized: base for base, family in _specializations.items() for specialized in family
+}
 
 _specialization_stats = [
     "success",

diff --git a/Lib/test/test_dis.py b/Lib/test/test_dis.py
@@ -682,9 +682,7 @@ def test_boundaries(self):
 
     def test_widths(self):
         for opcode, opname in enumerate(dis.opname):
-            if opname in ('BUILD_MAP_UNPACK_WITH_CALL',
-                          'BUILD_TUPLE_UNPACK_WITH_CALL',
-                          'JUMP_IF_NOT_EXC_MATCH'):
+            if opname in dis.deoptmap or opname == "JUMP_IF_NOT_EXC_MATCH":
                 continue
             with self.subTest(opname=opname):
                 width = dis._OPNAME_WIDTH

diff --git a/Tools/scripts/generate_opcode_h.py b/Tools/scripts/generate_opcode_h.py
@@ -61,13 +61,13 @@ def main(opcode_py, outfile='Include/opcode.h'):
     with open(outfile, 'w') as fobj:
         fobj.write(header)
         for name in opname:
-            if name in opmap and opmap[name] not in deoptmap:
+            if name in opmap and name not in deoptmap:
                 fobj.write(DEFINE.format(name, opmap[name]))
             if name == 'POP_EXCEPT': # Special entry for HAVE_ARGUMENT
                 fobj.write(DEFINE.format("HAVE_ARGUMENT", opcode["HAVE_ARGUMENT"]))
 
-        for spec_op in deoptmap:
-            fobj.write(DEFINE.format(opname[spec_op], spec_op))
+        for spec_name in deoptmap:
+            fobj.write(DEFINE.format(spec_name, opmap[spec_name]))
         fobj.write(DEFINE.format('DO_TRACING', 255))
         fobj.write("\nextern const uint8_t _PyOpcode_Caches[256];\n")
         fobj.write("\nextern const uint8_t _PyOpcode_Deopt[256];\n")
@@ -82,7 +82,7 @@ def main(opcode_py, outfile='Include/opcode.h'):
         fobj.write("};\n")
         fobj.write("\nconst uint8_t _PyOpcode_Deopt[256] = {\n")
         for opt, deopt in sorted(deoptmap.items()):
-            fobj.write(f"    [{opname[opt]}] = {opname[deopt]},\n")
+            fobj.write(f"    [{opt}] = {deopt},\n")
         fobj.write("};\n")
         fobj.write("#endif /* OPCODE_TABLES */\n")