Revert "Dict dispatch improvement"

This reverts commit 780aac9.

Author: 3tty0n

rpython/jit/codewriter/genextension.py

@@ -171,41 +171,29 @@ def _analyze_pc_transitions(self, code_and_spec_per_pc):
     def _generate_dict_dispatch(self, code_and_spec_per_pc, allconsts, pc_transitions):
         """
         Generate dictionary-based dispatch for O(1) PC lookup.
-        Uses a dense index mapping for better branch prediction.
+        This is more efficient for functions with many PC values.
 
-        Maps sparse PC values to dense indices (0, 1, 2, ...) and uses
-        the index for dispatch. The dictionary lookup is O(1).
+        For large functions, we use a true dictionary-based dispatch where
+        each PC handler is a closure that updates pc and continues.
         """
-        # Build the dispatch cases with dense indices
+        # Build the dispatch cases
         dispatch_cases = []
-        pc_to_idx = {}
-        for idx, (pc, (code, spec)) in enumerate(sorted(code_and_spec_per_pc.iteritems())):
+        for pc, (code, spec) in sorted(code_and_spec_per_pc.iteritems()):
             allconsts.update(spec.constant_registers)
             case_lines = []
             case_lines.append("self.pc = %s" % (self.pc_to_nextpc[spec.orig_pc], ))
             for line in str(py.code.Source(code).indent('')).splitlines():
                 case_lines.append(line)
-            dispatch_cases.append((idx, pc, case_lines, spec))
-            pc_to_idx[pc] = idx
-
-        # Generate PC to index mapping as a dictionary lookup
-        # This is O(1) dictionary lookup followed by O(1) index dispatch
-        self.code.append("_pc_to_idx = {%s}" % ", ".join(
-            "%s: %s" % (pc, idx) for pc, idx in sorted(pc_to_idx.items())))
-        self.code.append("_idx = _pc_to_idx.get(pc, -1)")
+            dispatch_cases.append((pc, case_lines, spec))
 
-        # Generate dispatch using dense indices for better branch prediction
-        prefix = ""
-        for idx, pc, case_lines, spec in dispatch_cases:
-            self.code.append("%sif _idx == %s: # pc=%s %s %s" % (prefix, idx, pc, spec.insn, spec.constant_registers))
+        # Generate the dispatch code - still use if/elif but with optimized ordering
+        # based on trace prediction (most likely targets first)
+        for pc, case_lines, spec in dispatch_cases:
+            self.code.append("if pc == %s: # %s %s" % (pc, spec.insn, spec.constant_registers))
             for line in case_lines:
                 self.code.append("    " + line)
-            # Update index for next iteration using the dictionary
-            next_pc_line = "    _idx = _pc_to_idx.get(pc, -1)"
-            self.code.append(next_pc_line)
-            prefix = "el"
 
-        self.code.append("else: assert 0, 'unreachable pc=%d' % pc")
+        self.code.append("assert 0 # unreachable")
 
     def _generate_threaded_dispatch(self, code_and_spec_per_pc, allconsts, pc_transitions):
         """