[pypy-commit] pypy translation-cleanup: Move opcode decoding to new class HostCode

[rlamy]

Author: Ronan Lamy <ronan.lamy at gmail.com>
Branch: translation-cleanup
Changeset: r56994:e94ac64d748f
Date: 2012-08-11 21:14 +0100
http://bitbucket.org/pypy/pypy/changeset/e94ac64d748f/

Log:	Move opcode decoding to new class HostCode

diff --git a/pypy/interpreter/pycode.py b/pypy/interpreter/pycode.py
--- a/pypy/interpreter/pycode.py
+++ b/pypy/interpreter/pycode.py
@@ -19,6 +19,10 @@
 from pypy.rlib.objectmodel import compute_hash
 from pypy.tool.stdlib_opcode import opcodedesc, HAVE_ARGUMENT
 
+
+class BytecodeCorruption(Exception):
+    """Detected bytecode corruption.  Never caught; it's an error."""
+
 # helper
 
 def unpack_str_tuple(space,w_str_tuple):
diff --git a/pypy/interpreter/pyopcode.py b/pypy/interpreter/pyopcode.py
--- a/pypy/interpreter/pyopcode.py
+++ b/pypy/interpreter/pyopcode.py
@@ -8,7 +8,7 @@
 from pypy.interpreter.error import OperationError, operationerrfmt
 from pypy.interpreter.baseobjspace import Wrappable
 from pypy.interpreter import gateway, function, eval, pyframe, pytraceback
-from pypy.interpreter.pycode import PyCode
+from pypy.interpreter.pycode import PyCode, BytecodeCorruption
 from pypy.tool.sourcetools import func_with_new_name
 from pypy.rlib.objectmodel import we_are_translated
 from pypy.rlib import jit, rstackovf
@@ -1172,9 +1172,6 @@
     def __init__(self, operr):
         self.operr = operr
 
-class BytecodeCorruption(Exception):
-    """Detected bytecode corruption.  Never caught; it's an error."""
-
 
 ### Frame Blocks ###
 
diff --git a/pypy/objspace/flow/bytecode.py b/pypy/objspace/flow/bytecode.py
new file mode 100644
--- /dev/null
+++ b/pypy/objspace/flow/bytecode.py
@@ -0,0 +1,42 @@
+"""
+Bytecode handling classes and functions for use by the flow space.
+"""
+from pypy.interpreter.pycode import PyCode, BytecodeCorruption
+from pypy.tool.stdlib_opcode import (host_bytecode_spec, EXTENDED_ARG,
+        HAVE_ARGUMENT)
+
+class HostCode(PyCode):
+    """
+    A wrapper around a native code object of the host interpreter
+    """
+    opnames = host_bytecode_spec.method_names
+
+    def read(self, pos):
+        """
+        Decode the instruction starting at position ``next_instr``.
+
+        Returns (next_instr, opname, oparg).
+        """
+        co_code = self.co_code
+        opcode = ord(co_code[pos])
+        next_instr = pos + 1
+
+        if opcode >= HAVE_ARGUMENT:
+            lo = ord(co_code[next_instr])
+            hi = ord(co_code[next_instr+1])
+            next_instr += 2
+            oparg = (hi * 256) | lo
+        else:
+            oparg = 0
+
+        while opcode == EXTENDED_ARG:
+            opcode = ord(co_code[next_instr])
+            if opcode < HAVE_ARGUMENT:
+                raise BytecodeCorruption
+            lo = ord(co_code[next_instr+1])
+            hi = ord(co_code[next_instr+2])
+            next_instr += 3
+            oparg = (oparg * 65536) | (hi * 256) | lo
+
+        opname = self.opnames[opcode]
+        return next_instr, opname, oparg
diff --git a/pypy/objspace/flow/flowcontext.py b/pypy/objspace/flow/flowcontext.py
--- a/pypy/objspace/flow/flowcontext.py
+++ b/pypy/objspace/flow/flowcontext.py
@@ -5,14 +5,13 @@
 from pypy.interpreter import pyframe, nestedscope
 from pypy.interpreter.argument import ArgumentsForTranslation
 from pypy.interpreter.astcompiler.consts import CO_GENERATOR
-from pypy.interpreter.pycode import PyCode, cpython_code_signature
 from pypy.interpreter.pyopcode import (Return, Yield, SuspendedUnroller,
         SReturnValue, BytecodeCorruption)
 from pypy.objspace.flow import operation
 from pypy.objspace.flow.model import *
 from pypy.objspace.flow.framestate import (FrameState, recursively_unflatten,
         recursively_flatten)
-from pypy.tool.stdlib_opcode import host_bytecode_spec
+from pypy.objspace.flow.bytecode import HostCode
 
 class StopFlowing(Exception):
     pass
@@ -194,7 +193,7 @@
 
     def build_flow(self, func, constargs={}):
         space = self.space
-        code = PyCode._from_code(space, func.func_code)
+        code = HostCode._from_code(space, func.func_code)
         self.code = code
 
         self.frame = frame = FlowSpaceFrame(self.space, code,
@@ -210,7 +209,7 @@
                 frame.frame_finished_execution = False
                 next_instr = frame.last_instr
                 while True:
-                    next_instr = frame.handle_bytecode(code.co_code,
+                    next_instr = frame.handle_bytecode(code,
                             next_instr, self)
 
             except operation.OperationThatShouldNotBePropagatedError, e:
@@ -435,33 +434,11 @@
             prevblock = parent
         return recorder
 
-    def dispatch_bytecode(self, co_code, next_instr, ec):
-        space = self.space
+    def dispatch_bytecode(self, code, next_instr, ec):
         while True:
             self.last_instr = next_instr
             ec.bytecode_trace(self)
-            opcode = ord(co_code[next_instr])
-            next_instr += 1
-
-            if opcode >= self.HAVE_ARGUMENT:
-                lo = ord(co_code[next_instr])
-                hi = ord(co_code[next_instr+1])
-                next_instr += 2
-                oparg = (hi * 256) | lo
-            else:
-                oparg = 0
-
-            while opcode == self.opcodedesc.EXTENDED_ARG.index:
-                opcode = ord(co_code[next_instr])
-                if opcode < self.HAVE_ARGUMENT:
-                    raise BytecodeCorruption
-                lo = ord(co_code[next_instr+1])
-                hi = ord(co_code[next_instr+2])
-                next_instr += 3
-                oparg = (oparg * 65536) | (hi * 256) | lo
-
-
-            methodname = self.opcode_method_names[opcode]
+            next_instr, methodname, oparg = code.read(next_instr)
             try:
                 meth = getattr(self, methodname)
             except AttributeError: