[pypy-svn] r74228 - pypy/branch/blackhole-improvement/pypy/jit/metainterp

arigo at codespeak.net arigo at codespeak.net
Thu Apr 29 17:02:57 CEST 2010


Author: arigo
Date: Thu Apr 29 17:02:55 2010
New Revision: 74228

Modified:
   pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
   pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py
Log:
Rename opimpl_xxx to bhimpl_xxx to avoid confusing them
with the opimpl_xxx functions in pyjitpl.


Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py	(original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/blackhole.py	Thu Apr 29 17:02:55 2010
@@ -141,7 +141,7 @@
             if verbose and not we_are_translated():
                 print '\t', name, list(args),
 
-            # call the method opimpl_xxx()
+            # call the method bhimpl_xxx()
             try:
                 result = unboundmethod(*args)
             except Exception, e:
@@ -189,11 +189,11 @@
             assert next_argcode == len(argcodes)
             return position
         #
-        # Get the opimpl_xxx method.  If we get an AttributeError here,
+        # Get the bhimpl_xxx method.  If we get an AttributeError here,
         # it means that either the implementation is missing, or that it
         # should not appear here at all but instead be transformed away
         # by codewriter/jitter.py.
-        unboundmethod = getattr(BlackholeInterpreter, 'opimpl_' + name).im_func
+        unboundmethod = getattr(BlackholeInterpreter, 'bhimpl_' + name).im_func
         verbose = self.verbose
         argtypes = unrolling_iterable(unboundmethod.argtypes)
         resulttype = unboundmethod.resulttype
@@ -333,315 +333,315 @@
     # ----------
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_add(a, b):
+    def bhimpl_int_add(a, b):
         return intmask(a + b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_sub(a, b):
+    def bhimpl_int_sub(a, b):
         return intmask(a - b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_mul(a, b):
+    def bhimpl_int_mul(a, b):
         return intmask(a * b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_add_ovf(a, b):
+    def bhimpl_int_add_ovf(a, b):
         return ovfcheck(a + b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_sub_ovf(a, b):
+    def bhimpl_int_sub_ovf(a, b):
         return ovfcheck(a - b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_mul_ovf(a, b):
+    def bhimpl_int_mul_ovf(a, b):
         return ovfcheck(a * b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_floordiv(a, b):
+    def bhimpl_int_floordiv(a, b):
         return llop.int_floordiv(lltype.Signed, a, b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_uint_floordiv(a, b):
+    def bhimpl_uint_floordiv(a, b):
         c = llop.uint_floordiv(lltype.Unsigned, r_uint(a), r_uint(b))
         return intmask(c)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_mod(a, b):
+    def bhimpl_int_mod(a, b):
         return llop.int_mod(lltype.Signed, a, b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_and(a, b):
+    def bhimpl_int_and(a, b):
         return a & b
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_or(a, b):
+    def bhimpl_int_or(a, b):
         return a | b
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_xor(a, b):
+    def bhimpl_int_xor(a, b):
         return a ^ b
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_rshift(a, b):
+    def bhimpl_int_rshift(a, b):
         return a >> b
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_lshift(a, b):
+    def bhimpl_int_lshift(a, b):
         return intmask(a << b)
 
     @arguments("i", "i", returns="i")
-    def opimpl_uint_rshift(a, b):
+    def bhimpl_uint_rshift(a, b):
         c = r_uint(a) >> r_uint(b)
         return intmask(c)
 
     @arguments("i", returns="i")
-    def opimpl_int_neg(a):
+    def bhimpl_int_neg(a):
         return intmask(-a)
 
     @arguments("i", returns="i")
-    def opimpl_int_invert(a):
+    def bhimpl_int_invert(a):
         return intmask(~a)
 
     @arguments("i", "i", returns="i")
-    def opimpl_int_lt(a, b):
+    def bhimpl_int_lt(a, b):
         return a < b
     @arguments("i", "i", returns="i")
-    def opimpl_int_le(a, b):
+    def bhimpl_int_le(a, b):
         return a <= b
     @arguments("i", "i", returns="i")
-    def opimpl_int_eq(a, b):
+    def bhimpl_int_eq(a, b):
         return a == b
     @arguments("i", "i", returns="i")
-    def opimpl_int_ne(a, b):
+    def bhimpl_int_ne(a, b):
         return a != b
     @arguments("i", "i", returns="i")
-    def opimpl_int_gt(a, b):
+    def bhimpl_int_gt(a, b):
         return a > b
     @arguments("i", "i", returns="i")
-    def opimpl_int_ge(a, b):
+    def bhimpl_int_ge(a, b):
         return a >= b
     @arguments("i", returns="i")
-    def opimpl_int_is_zero(a):
+    def bhimpl_int_is_zero(a):
         return not a
     @arguments("i", returns="i")
-    def opimpl_int_is_true(a):
+    def bhimpl_int_is_true(a):
         return bool(a)
 
     @arguments("i", "i", returns="i")
-    def opimpl_uint_lt(a, b):
+    def bhimpl_uint_lt(a, b):
         return r_uint(a) < r_uint(b)
     @arguments("i", "i", returns="i")
-    def opimpl_uint_le(a, b):
+    def bhimpl_uint_le(a, b):
         return r_uint(a) <= r_uint(b)
     @arguments("i", "i", returns="i")
-    def opimpl_uint_gt(a, b):
+    def bhimpl_uint_gt(a, b):
         return r_uint(a) > r_uint(b)
     @arguments("i", "i", returns="i")
-    def opimpl_uint_ge(a, b):
+    def bhimpl_uint_ge(a, b):
         return r_uint(a) >= r_uint(b)
 
     @arguments("r", "r", returns="i")
-    def opimpl_ptr_eq(a, b):
+    def bhimpl_ptr_eq(a, b):
         return a == b
     @arguments("r", "r", returns="i")
-    def opimpl_ptr_ne(a, b):
+    def bhimpl_ptr_ne(a, b):
         return a != b
     @arguments("r", returns="i")
-    def opimpl_ptr_iszero(a):
+    def bhimpl_ptr_iszero(a):
         return not a
     @arguments("r", returns="i")
-    def opimpl_ptr_nonzero(a):
+    def bhimpl_ptr_nonzero(a):
         return bool(a)
 
     @arguments("i", returns="i")
-    def opimpl_int_copy(a):
+    def bhimpl_int_copy(a):
         return a
     @arguments("r", returns="r")
-    def opimpl_ref_copy(a):
+    def bhimpl_ref_copy(a):
         return a
     @arguments("f", returns="f")
-    def opimpl_float_copy(a):
+    def bhimpl_float_copy(a):
         return a
 
-    opimpl_int_guard_value = opimpl_int_copy
-    opimpl_ref_guard_value = opimpl_ref_copy
-    opimpl_float_guard_value = opimpl_float_copy
+    bhimpl_int_guard_value = bhimpl_int_copy
+    bhimpl_ref_guard_value = bhimpl_ref_copy
+    bhimpl_float_guard_value = bhimpl_float_copy
 
     # ----------
     # float operations
 
     @arguments("f", returns="f")
-    def opimpl_float_neg(a):
+    def bhimpl_float_neg(a):
         return -a
     @arguments("f", returns="f")
-    def opimpl_float_abs(a):
+    def bhimpl_float_abs(a):
         return abs(a)
     @arguments("f", returns="i")
-    def opimpl_float_is_true(a):
+    def bhimpl_float_is_true(a):
         return bool(a)
 
     @arguments("f", "f", returns="f")
-    def opimpl_float_add(a, b):
+    def bhimpl_float_add(a, b):
         return a + b
     @arguments("f", "f", returns="f")
-    def opimpl_float_sub(a, b):
+    def bhimpl_float_sub(a, b):
         return a - b
     @arguments("f", "f", returns="f")
-    def opimpl_float_mul(a, b):
+    def bhimpl_float_mul(a, b):
         return a * b
     @arguments("f", "f", returns="f")
-    def opimpl_float_truediv(a, b):
+    def bhimpl_float_truediv(a, b):
         return a / b
 
     @arguments("f", "f", returns="i")
-    def opimpl_float_lt(a, b):
+    def bhimpl_float_lt(a, b):
         return a < b
     @arguments("f", "f", returns="i")
-    def opimpl_float_le(a, b):
+    def bhimpl_float_le(a, b):
         return a <= b
     @arguments("f", "f", returns="i")
-    def opimpl_float_eq(a, b):
+    def bhimpl_float_eq(a, b):
         return a == b
     @arguments("f", "f", returns="i")
-    def opimpl_float_ne(a, b):
+    def bhimpl_float_ne(a, b):
         return a != b
     @arguments("f", "f", returns="i")
-    def opimpl_float_gt(a, b):
+    def bhimpl_float_gt(a, b):
         return a > b
     @arguments("f", "f", returns="i")
-    def opimpl_float_ge(a, b):
+    def bhimpl_float_ge(a, b):
         return a >= b
 
     @arguments("f", returns="i")
-    def opimpl_cast_float_to_int(a):
+    def bhimpl_cast_float_to_int(a):
         # note: we need to call int() twice to care for the fact that
         # int(-2147483648.0) returns a long :-(
         return int(int(a))
 
     @arguments("i", returns="f")
-    def opimpl_cast_int_to_float(a):
+    def bhimpl_cast_int_to_float(a):
         return float(a)
 
     # ----------
     # control flow operations
 
     @arguments("self", "i")
-    def opimpl_int_return(self, a):
+    def bhimpl_int_return(self, a):
         self.registers_i[0] = a
         if not we_are_translated():
             self._return_type = "int"
         raise LeaveFrame
 
     @arguments("self", "r")
-    def opimpl_ref_return(self, a):
+    def bhimpl_ref_return(self, a):
         self.registers_r[0] = a
         if not we_are_translated():
             self._return_type = "ref"
         raise LeaveFrame
 
     @arguments("self", "f")
-    def opimpl_float_return(self, a):
+    def bhimpl_float_return(self, a):
         self.registers_f[0] = a
         if not we_are_translated():
             self._return_type = "float"
         raise LeaveFrame
 
     @arguments("self")
-    def opimpl_void_return(self):
+    def bhimpl_void_return(self):
         if not we_are_translated():
             self._return_type = "void"
         raise LeaveFrame
 
     @arguments("L", "i", "pc", returns="L")
-    def opimpl_goto_if_not(target, a, pc):
+    def bhimpl_goto_if_not(target, a, pc):
         if a:
             return pc
         else:
             return target
 
     @arguments("L", "i", "i", "pc", returns="L")
-    def opimpl_goto_if_not_int_lt(target, a, b, pc):
+    def bhimpl_goto_if_not_int_lt(target, a, b, pc):
         if a < b:
             return pc
         else:
             return target
 
     @arguments("L", "i", "i", "pc", returns="L")
-    def opimpl_goto_if_not_int_le(target, a, b, pc):
+    def bhimpl_goto_if_not_int_le(target, a, b, pc):
         if a <= b:
             return pc
         else:
             return target
 
     @arguments("L", "i", "i", "pc", returns="L")
-    def opimpl_goto_if_not_int_eq(target, a, b, pc):
+    def bhimpl_goto_if_not_int_eq(target, a, b, pc):
         if a == b:
             return pc
         else:
             return target
 
     @arguments("L", "i", "i", "pc", returns="L")
-    def opimpl_goto_if_not_int_ne(target, a, b, pc):
+    def bhimpl_goto_if_not_int_ne(target, a, b, pc):
         if a != b:
             return pc
         else:
             return target
 
     @arguments("L", "i", "i", "pc", returns="L")
-    def opimpl_goto_if_not_int_gt(target, a, b, pc):
+    def bhimpl_goto_if_not_int_gt(target, a, b, pc):
         if a > b:
             return pc
         else:
             return target
 
     @arguments("L", "i", "i", "pc", returns="L")
-    def opimpl_goto_if_not_int_ge(target, a, b, pc):
+    def bhimpl_goto_if_not_int_ge(target, a, b, pc):
         if a >= b:
             return pc
         else:
             return target
 
     @arguments("L", "i", "pc", returns="L")
-    def opimpl_goto_if_not_int_is_zero(target, a, pc):
+    def bhimpl_goto_if_not_int_is_zero(target, a, pc):
         if not a:
             return pc
         else:
             return target
 
     @arguments("L", "r", "r", "pc", returns="L")
-    def opimpl_goto_if_not_ptr_eq(target, a, b, pc):
+    def bhimpl_goto_if_not_ptr_eq(target, a, b, pc):
         if a == b:
             return pc
         else:
             return target
 
     @arguments("L", "r", "r", "pc", returns="L")
-    def opimpl_goto_if_not_ptr_ne(target, a, b, pc):
+    def bhimpl_goto_if_not_ptr_ne(target, a, b, pc):
         if a != b:
             return pc
         else:
             return target
 
     @arguments("L", "r", "pc", returns="L")
-    def opimpl_goto_if_not_ptr_iszero(target, a, pc):
+    def bhimpl_goto_if_not_ptr_iszero(target, a, pc):
         if not a:
             return pc
         else:
             return target
 
     @arguments("L", "r", "pc", returns="L")
-    def opimpl_goto_if_not_ptr_nonzero(target, a, pc):
+    def bhimpl_goto_if_not_ptr_nonzero(target, a, pc):
         if a:
             return pc
         else:
             return target
 
     @arguments("L", returns="L")
-    def opimpl_goto(target):
+    def bhimpl_goto(target):
         return target
 
     @arguments("i", "d", "pc", returns="L")
-    def opimpl_switch(switchvalue, switchdict, pc):
+    def bhimpl_switch(switchvalue, switchdict, pc):
         assert isinstance(switchdict, SwitchDictDescr)
         try:
             return switchdict.dict[switchvalue]
@@ -649,14 +649,14 @@
             return pc
 
     @arguments("L")
-    def opimpl_catch_exception(target):
+    def bhimpl_catch_exception(target):
         """This is a no-op when run normally.  When an exception occurs
         and the instruction that raised is immediately followed by a
         catch_exception, then the code in handle_exception_in_frame()
         will capture the exception and jump to 'target'."""
 
     @arguments("self", "i", "L", "pc", returns="L")
-    def opimpl_goto_if_exception_mismatch(self, vtable, target, pc):
+    def bhimpl_goto_if_exception_mismatch(self, vtable, target, pc):
         adr = llmemory.cast_int_to_adr(vtable)
         bounding_class = llmemory.cast_adr_to_ptr(adr, rclass.CLASSTYPE)
         real_instance = self.exception_last_value
@@ -667,20 +667,20 @@
             return target
 
     @arguments("self", returns="i")
-    def opimpl_last_exception(self):
+    def bhimpl_last_exception(self):
         real_instance = self.exception_last_value
         assert real_instance
         adr = llmemory.cast_ptr_to_adr(real_instance.typeptr)
         return llmemory.cast_adr_to_int(adr)
 
     @arguments("self", returns="r")
-    def opimpl_last_exc_value(self):
+    def bhimpl_last_exc_value(self):
         real_instance = self.exception_last_value
         assert real_instance
         return lltype.cast_opaque_ptr(llmemory.GCREF, real_instance)
 
     @arguments("self")
-    def opimpl_reraise(self):
+    def bhimpl_reraise(self):
         real_instance = self.exception_last_value
         assert real_instance
         raise real_instance
@@ -689,139 +689,139 @@
     # the following operations are directly implemented by the backend
 
     @arguments("self", "i", "d", "R", returns="i")
-    def opimpl_residual_call_r_i(self, func, calldescr, args_r):
+    def bhimpl_residual_call_r_i(self, func, calldescr, args_r):
         return self.cpu.bh_call_i(func, calldescr, None, args_r, None)
     @arguments("self", "i", "d", "R", returns="r")
-    def opimpl_residual_call_r_r(self, func, calldescr, args_r):
+    def bhimpl_residual_call_r_r(self, func, calldescr, args_r):
         return self.cpu.bh_call_r(func, calldescr, None, args_r, None)
     @arguments("self", "i", "d", "R", returns="f")
-    def opimpl_residual_call_r_f(self, func, calldescr, args_r):
+    def bhimpl_residual_call_r_f(self, func, calldescr, args_r):
         return self.cpu.bh_call_f(func, calldescr, None, args_r, None)
     @arguments("self", "i", "d", "R")
-    def opimpl_residual_call_r_v(self, func, calldescr, args_r):
+    def bhimpl_residual_call_r_v(self, func, calldescr, args_r):
         self.cpu.bh_call_v(func, calldescr, None, args_r, None)
 
     @arguments("self", "i", "d", "I", "R", returns="i")
-    def opimpl_residual_call_ir_i(self, func, calldescr, args_i, args_r):
+    def bhimpl_residual_call_ir_i(self, func, calldescr, args_i, args_r):
         return self.cpu.bh_call_i(func, calldescr, args_i, args_r, None)
     @arguments("self", "i", "d", "I", "R", returns="r")
-    def opimpl_residual_call_ir_r(self, func, calldescr, args_i, args_r):
+    def bhimpl_residual_call_ir_r(self, func, calldescr, args_i, args_r):
         return self.cpu.bh_call_r(func, calldescr, args_i, args_r, None)
     @arguments("self", "i", "d", "I", "R", returns="f")
-    def opimpl_residual_call_ir_f(self, func, calldescr, args_i, args_r):
+    def bhimpl_residual_call_ir_f(self, func, calldescr, args_i, args_r):
         return self.cpu.bh_call_f(func, calldescr, args_i, args_r, None)
     @arguments("self", "i", "d", "I", "R")
-    def opimpl_residual_call_ir_v(self, func, calldescr, args_i, args_r):
+    def bhimpl_residual_call_ir_v(self, func, calldescr, args_i, args_r):
         self.cpu.bh_call_v(func, calldescr, args_i, args_r, None)
 
     @arguments("self", "i", "d", "I", "R", "F", returns="i")
-    def opimpl_residual_call_irf_i(self, func, calldescr,args_i,args_r,args_f):
+    def bhimpl_residual_call_irf_i(self, func, calldescr,args_i,args_r,args_f):
         return self.cpu.bh_call_i(func, calldescr, args_i, args_r, args_f)
     @arguments("self", "i", "d", "I", "R", "F", returns="r")
-    def opimpl_residual_call_irf_r(self, func, calldescr,args_i,args_r,args_f):
+    def bhimpl_residual_call_irf_r(self, func, calldescr,args_i,args_r,args_f):
         return self.cpu.bh_call_r(func, calldescr, args_i, args_r, args_f)
     @arguments("self", "i", "d", "I", "R", "F", returns="f")
-    def opimpl_residual_call_irf_f(self, func, calldescr,args_i,args_r,args_f):
+    def bhimpl_residual_call_irf_f(self, func, calldescr,args_i,args_r,args_f):
         return self.cpu.bh_call_f(func, calldescr, args_i, args_r, args_f)
     @arguments("self", "i", "d", "I", "R", "F")
-    def opimpl_residual_call_irf_v(self, func, calldescr,args_i,args_r,args_f):
+    def bhimpl_residual_call_irf_v(self, func, calldescr,args_i,args_r,args_f):
         self.cpu.bh_call_v(func, calldescr, args_i, args_r, args_f)
 
     @arguments("self", "d", "i", returns="r")
-    def opimpl_new_array(self, arraydescr, length):
+    def bhimpl_new_array(self, arraydescr, length):
         return self.cpu.bh_new_array(arraydescr, length)
     @arguments("self", "d", "r", "i", "r")
-    def opimpl_setarrayitem_gc_r(self, arraydescr, array, index, newvalue):
+    def bhimpl_setarrayitem_gc_r(self, arraydescr, array, index, newvalue):
         self.cpu.bh_setarrayitem_gc_r(arraydescr, array, index, newvalue)
 
     @arguments("self", "r", "d", returns="i")
-    def opimpl_getfield_gc_i(self, struct, fielddescr):
+    def bhimpl_getfield_gc_i(self, struct, fielddescr):
         return self.cpu.bh_getfield_gc_i(struct, fielddescr)
     @arguments("self", "r", "d", returns="i")
-    def opimpl_getfield_gc_c(self, struct, fielddescr):
+    def bhimpl_getfield_gc_c(self, struct, fielddescr):
         return self.cpu.bh_getfield_gc_c(struct, fielddescr)
     @arguments("self", "r", "d", returns="i")
-    def opimpl_getfield_gc_u(self, struct, fielddescr):
+    def bhimpl_getfield_gc_u(self, struct, fielddescr):
         return self.cpu.bh_getfield_gc_u(struct, fielddescr)
     @arguments("self", "r", "d", returns="r")
-    def opimpl_getfield_gc_r(self, struct, fielddescr):
+    def bhimpl_getfield_gc_r(self, struct, fielddescr):
         return self.cpu.bh_getfield_gc_r(struct, fielddescr)
     @arguments("self", "r", "d", returns="f")
-    def opimpl_getfield_gc_f(self, struct, fielddescr):
+    def bhimpl_getfield_gc_f(self, struct, fielddescr):
         return self.cpu.bh_getfield_gc_f(struct, fielddescr)
 
-    opimpl_getfield_gc_i_pure = opimpl_getfield_gc_i
-    opimpl_getfield_gc_c_pure = opimpl_getfield_gc_c
-    opimpl_getfield_gc_u_pure = opimpl_getfield_gc_u
-    opimpl_getfield_gc_r_pure = opimpl_getfield_gc_r
-    opimpl_getfield_gc_f_pure = opimpl_getfield_gc_f
+    bhimpl_getfield_gc_i_pure = bhimpl_getfield_gc_i
+    bhimpl_getfield_gc_c_pure = bhimpl_getfield_gc_c
+    bhimpl_getfield_gc_u_pure = bhimpl_getfield_gc_u
+    bhimpl_getfield_gc_r_pure = bhimpl_getfield_gc_r
+    bhimpl_getfield_gc_f_pure = bhimpl_getfield_gc_f
 
     @arguments("self", "i", "d", returns="i")
-    def opimpl_getfield_raw_i(self, struct, fielddescr):
+    def bhimpl_getfield_raw_i(self, struct, fielddescr):
         return self.cpu.bh_getfield_raw_i(struct, fielddescr)
     @arguments("self", "i", "d", returns="i")
-    def opimpl_getfield_raw_c(self, struct, fielddescr):
+    def bhimpl_getfield_raw_c(self, struct, fielddescr):
         return self.cpu.bh_getfield_raw_c(struct, fielddescr)
     @arguments("self", "i", "d", returns="i")
-    def opimpl_getfield_raw_u(self, struct, fielddescr):
+    def bhimpl_getfield_raw_u(self, struct, fielddescr):
         return self.cpu.bh_getfield_raw_u(struct, fielddescr)
     @arguments("self", "i", "d", returns="r")
-    def opimpl_getfield_raw_r(self, struct, fielddescr):
+    def bhimpl_getfield_raw_r(self, struct, fielddescr):
         return self.cpu.bh_getfield_raw_r(struct, fielddescr)
     @arguments("self", "i", "d", returns="f")
-    def opimpl_getfield_raw_f(self, struct, fielddescr):
+    def bhimpl_getfield_raw_f(self, struct, fielddescr):
         return self.cpu.bh_getfield_raw_f(struct, fielddescr)
 
-    opimpl_getfield_raw_i_pure = opimpl_getfield_raw_i
-    opimpl_getfield_raw_c_pure = opimpl_getfield_raw_c
-    opimpl_getfield_raw_u_pure = opimpl_getfield_raw_u
-    opimpl_getfield_raw_r_pure = opimpl_getfield_raw_r
-    opimpl_getfield_raw_f_pure = opimpl_getfield_raw_f
+    bhimpl_getfield_raw_i_pure = bhimpl_getfield_raw_i
+    bhimpl_getfield_raw_c_pure = bhimpl_getfield_raw_c
+    bhimpl_getfield_raw_u_pure = bhimpl_getfield_raw_u
+    bhimpl_getfield_raw_r_pure = bhimpl_getfield_raw_r
+    bhimpl_getfield_raw_f_pure = bhimpl_getfield_raw_f
 
     @arguments("self", "r", "d", "i")
-    def opimpl_setfield_gc_i(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_gc_i(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_gc_i(struct, fielddescr, newvalue)
     @arguments("self", "r", "d", "i")
-    def opimpl_setfield_gc_c(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_gc_c(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_gc_c(struct, fielddescr, newvalue)
     @arguments("self", "r", "d", "i")
-    def opimpl_setfield_gc_u(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_gc_u(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_gc_u(struct, fielddescr, newvalue)
     @arguments("self", "r", "d", "r")
-    def opimpl_setfield_gc_r(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_gc_r(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_gc_r(struct, fielddescr, newvalue)
     @arguments("self", "r", "d", "f")
-    def opimpl_setfield_gc_f(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_gc_f(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_gc_f(struct, fielddescr, newvalue)
 
     @arguments("self", "i", "d", "i")
-    def opimpl_setfield_raw_i(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_raw_i(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_raw_i(struct, fielddescr, newvalue)
     @arguments("self", "i", "d", "i")
-    def opimpl_setfield_raw_c(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_raw_c(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_raw_c(struct, fielddescr, newvalue)
     @arguments("self", "i", "d", "i")
-    def opimpl_setfield_raw_u(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_raw_u(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_raw_u(struct, fielddescr, newvalue)
     @arguments("self", "i", "d", "r")
-    def opimpl_setfield_raw_r(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_raw_r(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_raw_r(struct, fielddescr, newvalue)
     @arguments("self", "i", "d", "f")
-    def opimpl_setfield_raw_f(self, struct, fielddescr, newvalue):
+    def bhimpl_setfield_raw_f(self, struct, fielddescr, newvalue):
         self.cpu.bh_setfield_raw_f(struct, fielddescr, newvalue)
 
     @arguments("self", "d", returns="r")
-    def opimpl_new(self, descr):
+    def bhimpl_new(self, descr):
         return self.cpu.bh_new(descr)
 
     @arguments("self", "d", returns="r")
-    def opimpl_new_with_vtable(self, descr):
+    def bhimpl_new_with_vtable(self, descr):
         return self.cpu.bh_new_with_vtable(descr)
 
     @arguments("self", "r", returns="i")
-    def opimpl_guard_class(self, struct):
+    def bhimpl_guard_class(self, struct):
         return self.cpu.bh_classof(struct)
 
     @arguments("self", "r", returns="i")
-    def opimpl_cast_ptr_to_int(self, p):
+    def bhimpl_cast_ptr_to_int(self, p):
         return self.cpu.bh_cast_ptr_to_int(p)

Modified: pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py
==============================================================================
--- pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py	(original)
+++ pypy/branch/blackhole-improvement/pypy/jit/metainterp/executor.py	Thu Apr 29 17:02:55 2010
@@ -66,7 +66,7 @@
                 raise Exception("duplicate entry for op number %d" % value)
             if key.endswith('_PURE'):
                 key = key[:-5]
-            name = 'opimpl_' + key.lower()
+            name = 'bhimpl_' + key.lower()
             if hasattr(BlackholeInterpreter, name):
                 func = make_execute_function_with_boxes(
                     key.lower(),
@@ -78,7 +78,7 @@
     cpuclass._execute_by_num_args = execute_by_num_args
 
 def make_execute_function_with_boxes(name, func):
-    # Make a wrapper for 'func'.  The func is a simple opimpl_xxx function
+    # Make a wrapper for 'func'.  The func is a simple bhimpl_xxx function
     # from the BlackholeInterpreter class.  The wrapper is a new function
     # that receives and returns boxed values.
     for argtype in func.argtypes:



More information about the Pypy-commit mailing list