Author: Armin Rigo <ar...@tunes.org>
Branch:
Changeset: r85043:fbfec7254a35
Date: 2016-06-08 21:26 +0200
http://bitbucket.org/pypy/pypy/changeset/fbfec7254a35/
Log: Rename the RPython helpers from ll_int_floordiv() to
ll_int_py_div(), because they are doing Python-style rounding,
unlike llop.int_floordiv().
diff --git a/pypy/module/pypyjit/test_pypy_c/test_string.py
b/pypy/module/pypyjit/test_pypy_c/test_string.py
--- a/pypy/module/pypyjit/test_pypy_c/test_string.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_string.py
@@ -23,7 +23,7 @@
guard_true(i14, descr=...)
guard_not_invalidated(descr=...)
i16 = int_eq(i6, %d)
- i19 = call_i(ConstClass(ll_int_mod__Signed_Signed), i6, i10,
descr=<Calli . ii EF=0 OS=14>)
+ i19 = call_i(ConstClass(ll_int_py_mod__Signed_Signed), i6, i10,
descr=<Calli . ii EF=0 OS=14>)
i21 = int_lt(i19, 0)
guard_false(i21, descr=...)
i22 = int_ge(i19, i10)
diff --git a/rpython/jit/codewriter/support.py
b/rpython/jit/codewriter/support.py
--- a/rpython/jit/codewriter/support.py
+++ b/rpython/jit/codewriter/support.py
@@ -252,7 +252,7 @@
def _ll_2_int_floordiv(x, y):
# this is used only if the RPython program uses llop.int_floordiv()
# explicitly. For 'a // b', see _handle_int_special() in jtransform.py.
- # This is the reverse of rpython.rtyper.rint.ll_int_floordiv(), i.e.
+ # This is the reverse of rpython.rtyper.rint.ll_int_py_div(), i.e.
# the same logic as rpython.rtyper.lltypesystem.opimpl.op_int_floordiv
# but written in a no-branch style.
r = x // y
diff --git a/rpython/jit/codewriter/test/test_flatten.py
b/rpython/jit/codewriter/test/test_flatten.py
--- a/rpython/jit/codewriter/test/test_flatten.py
+++ b/rpython/jit/codewriter/test/test_flatten.py
@@ -478,7 +478,7 @@
except ZeroDivisionError:
return -42
self.encoding_test(f, [7, 2], """
- residual_call_ir_i $<* fn ll_int_floordiv_ovf_zer__Signed_Signed>,
I[%i0, %i1], R[], <Descr> -> %i2
+ residual_call_ir_i $<* fn ll_int_py_div_ovf_zer__Signed_Signed>,
I[%i0, %i1], R[], <Descr> -> %i2
-live-
catch_exception L1
int_return %i2
@@ -505,7 +505,7 @@
return 42
# XXX so far, this really produces a int_mod_ovf_zer...
self.encoding_test(f, [7, 2], """
- residual_call_ir_i $<* fn ll_int_mod_ovf_zer__Signed_Signed>,
I[%i0, %i1], R[], <Descr> -> %i2
+ residual_call_ir_i $<* fn ll_int_py_mod_ovf_zer__Signed_Signed>,
I[%i0, %i1], R[], <Descr> -> %i2
-live-
catch_exception L1
int_return %i2
diff --git a/rpython/rtyper/rint.py b/rpython/rtyper/rint.py
--- a/rpython/rtyper/rint.py
+++ b/rpython/rtyper/rint.py
@@ -236,11 +236,11 @@
return _rtype_template(hop, 'mul_ovf')
def rtype_floordiv(_, hop):
- return _rtype_call_helper(hop, 'floordiv', [ZeroDivisionError])
+ return _rtype_call_helper(hop, 'py_div', [ZeroDivisionError])
rtype_inplace_floordiv = rtype_floordiv
def rtype_floordiv_ovf(_, hop):
- return _rtype_call_helper(hop, 'floordiv_ovf', [ZeroDivisionError])
+ return _rtype_call_helper(hop, 'py_div_ovf', [ZeroDivisionError])
# turn 'div' on integers into 'floordiv'
rtype_div = rtype_floordiv
@@ -250,11 +250,11 @@
# 'def rtype_truediv' is delegated to the superclass FloatRepr
def rtype_mod(_, hop):
- return _rtype_call_helper(hop, 'mod', [ZeroDivisionError])
+ return _rtype_call_helper(hop, 'py_mod', [ZeroDivisionError])
rtype_inplace_mod = rtype_mod
def rtype_mod_ovf(_, hop):
- return _rtype_call_helper(hop, 'mod_ovf', [ZeroDivisionError])
+ return _rtype_call_helper(hop, 'py_mod_ovf', [ZeroDivisionError])
def rtype_xor(_, hop):
return _rtype_template(hop, 'xor')
@@ -319,7 +319,7 @@
vlist = hop.inputargs(repr, repr2)
prefix = repr.opprefix
- if '_ovf' in func or func.startswith(('mod', 'floordiv')):
+ if '_ovf' in func or func.startswith(('py_mod', 'py_div')):
if prefix+func not in ('int_add_ovf', 'int_add_nonneg_ovf',
'int_sub_ovf', 'int_mul_ovf'):
raise TyperError("%r should not be used here any more" % (func,))
@@ -353,7 +353,7 @@
any_implicit_exception = True
if not any_implicit_exception:
- if not func.startswith(('mod', 'floordiv')):
+ if not func.startswith(('py_mod', 'py_div')):
return _rtype_template(hop, func)
repr = hop.r_result
@@ -388,7 +388,7 @@
# ---------- floordiv ----------
@jit.oopspec("int.py_div(x, y)")
-def ll_int_floordiv(x, y):
+def ll_int_py_div(x, y):
# Python, and RPython, assume that integer division truncates
# towards -infinity. However, in C, integer division truncates
# towards 0. So assuming that, we need to apply a correction
@@ -400,159 +400,159 @@
return r + (u >> INT_BITS_1)
@jit.oopspec("int.py_div(x, y)")
-def ll_int_floordiv_nonnegargs(x, y):
+def ll_int_py_div_nonnegargs(x, y):
from rpython.rlib.debug import ll_assert
r = llop.int_floordiv(Signed, x, y) # <= truncates like in C
- ll_assert(r >= 0, "int_floordiv_nonnegargs(): one arg is negative")
+ ll_assert(r >= 0, "int_py_div_nonnegargs(): one arg is negative")
return r
-def ll_int_floordiv_zer(x, y):
+def ll_int_py_div_zer(x, y):
if y == 0:
raise ZeroDivisionError("integer division")
- return ll_int_floordiv(x, y)
+ return ll_int_py_div(x, y)
-def ll_int_floordiv_ovf(x, y):
+def ll_int_py_div_ovf(x, y):
# JIT: intentionally not short-circuited to produce only one guard
# and to remove the check fully if one of the arguments is known
if (x == -sys.maxint - 1) & (y == -1):
raise OverflowError("integer division")
- return ll_int_floordiv(x, y)
+ return ll_int_py_div(x, y)
-def ll_int_floordiv_ovf_zer(x, y):
+def ll_int_py_div_ovf_zer(x, y):
if y == 0:
raise ZeroDivisionError("integer division")
- return ll_int_floordiv_ovf(x, y)
+ return ll_int_py_div_ovf(x, y)
@jit.oopspec("int.udiv(x, y)")
-def ll_uint_floordiv(x, y):
+def ll_uint_py_div(x, y):
return llop.uint_floordiv(Unsigned, x, y)
-def ll_uint_floordiv_zer(x, y):
+def ll_uint_py_div_zer(x, y):
if y == 0:
raise ZeroDivisionError("unsigned integer division")
- return ll_uint_floordiv(x, y)
+ return ll_uint_py_div(x, y)
if SignedLongLong == Signed:
- ll_llong_floordiv = ll_int_floordiv
- ll_llong_floordiv_zer = ll_int_floordiv_zer
- ll_ullong_floordiv = ll_uint_floordiv
- ll_ullong_floordiv_zer = ll_uint_floordiv_zer
+ ll_llong_py_div = ll_int_py_div
+ ll_llong_py_div_zer = ll_int_py_div_zer
+ ll_ullong_py_div = ll_uint_py_div
+ ll_ullong_py_div_zer = ll_uint_py_div_zer
else:
@jit.dont_look_inside
- def ll_llong_floordiv(x, y):
+ def ll_llong_py_div(x, y):
r = llop.llong_floordiv(SignedLongLong, x, y) # <= truncates like in C
p = r * y
if y < 0: u = p - x
else: u = x - p
return r + (u >> LLONG_BITS_1)
- def ll_llong_floordiv_zer(x, y):
+ def ll_llong_py_div_zer(x, y):
if y == 0:
raise ZeroDivisionError("longlong division")
- return ll_llong_floordiv(x, y)
+ return ll_llong_py_div(x, y)
@jit.dont_look_inside
- def ll_ullong_floordiv(x, y):
+ def ll_ullong_py_div(x, y):
return llop.ullong_floordiv(UnsignedLongLong, x, y)
- def ll_ullong_floordiv_zer(x, y):
+ def ll_ullong_py_div_zer(x, y):
if y == 0:
raise ZeroDivisionError("unsigned longlong division")
- return ll_ullong_floordiv(x, y)
+ return ll_ullong_py_div(x, y)
@jit.dont_look_inside
-def ll_lllong_floordiv(x, y):
+def ll_lllong_py_div(x, y):
r = llop.lllong_floordiv(SignedLongLongLong, x, y) # <= truncates like in C
p = r * y
if y < 0: u = p - x
else: u = x - p
return r + (u >> LLLONG_BITS_1)
-def ll_lllong_floordiv_zer(x, y):
+def ll_lllong_py_div_zer(x, y):
if y == 0:
raise ZeroDivisionError("longlonglong division")
- return ll_lllong_floordiv(x, y)
+ return ll_lllong_py_div(x, y)
# ---------- mod ----------
@jit.oopspec("int.py_mod(x, y)")
-def ll_int_mod(x, y):
+def ll_int_py_mod(x, y):
r = llop.int_mod(Signed, x, y) # <= truncates like in C
if y < 0: u = -r
else: u = r
return r + (y & (u >> INT_BITS_1))
@jit.oopspec("int.py_mod(x, y)")
-def ll_int_mod_nonnegargs(x, y):
+def ll_int_py_mod_nonnegargs(x, y):
from rpython.rlib.debug import ll_assert
r = llop.int_mod(Signed, x, y) # <= truncates like in C
- ll_assert(r >= 0, "int_mod_nonnegargs(): one arg is negative")
+ ll_assert(r >= 0, "int_py_mod_nonnegargs(): one arg is negative")
return r
-def ll_int_mod_zer(x, y):
+def ll_int_py_mod_zer(x, y):
if y == 0:
raise ZeroDivisionError
- return ll_int_mod(x, y)
+ return ll_int_py_mod(x, y)
-def ll_int_mod_ovf(x, y):
- # see comment in ll_int_floordiv_ovf
+def ll_int_py_mod_ovf(x, y):
+ # see comment in ll_int_py_div_ovf
if (x == -sys.maxint - 1) & (y == -1):
raise OverflowError
- return ll_int_mod(x, y)
+ return ll_int_py_mod(x, y)
-def ll_int_mod_ovf_zer(x, y):
+def ll_int_py_mod_ovf_zer(x, y):
if y == 0:
raise ZeroDivisionError
- return ll_int_mod_ovf(x, y)
+ return ll_int_py_mod_ovf(x, y)
@jit.oopspec("int.umod(x, y)")
-def ll_uint_mod(x, y):
+def ll_uint_py_mod(x, y):
return llop.uint_mod(Unsigned, x, y)
-def ll_uint_mod_zer(x, y):
+def ll_uint_py_mod_zer(x, y):
if y == 0:
raise ZeroDivisionError
- return ll_uint_mod(x, y)
+ return ll_uint_py_mod(x, y)
if SignedLongLong == Signed:
- ll_llong_mod = ll_int_mod
- ll_llong_mod_zer = ll_int_mod_zer
- ll_ullong_mod = ll_uint_mod
- ll_ullong_mod_zer = ll_uint_mod_zer
+ ll_llong_py_mod = ll_int_py_mod
+ ll_llong_py_mod_zer = ll_int_py_mod_zer
+ ll_ullong_py_mod = ll_uint_py_mod
+ ll_ullong_py_mod_zer = ll_uint_py_mod_zer
else:
@jit.dont_look_inside
- def ll_llong_mod(x, y):
+ def ll_llong_py_mod(x, y):
r = llop.llong_mod(SignedLongLong, x, y) # <= truncates like in C
if y < 0: u = -r
else: u = r
return r + (y & (u >> LLONG_BITS_1))
- def ll_llong_mod_zer(x, y):
+ def ll_llong_py_mod_zer(x, y):
if y == 0:
raise ZeroDivisionError
- return ll_llong_mod(x, y)
+ return ll_llong_py_mod(x, y)
@jit.dont_look_inside
- def ll_ullong_mod(x, y):
+ def ll_ullong_py_mod(x, y):
return llop.ullong_mod(UnsignedLongLong, x, y)
- def ll_ullong_mod_zer(x, y):
+ def ll_ullong_py_mod_zer(x, y):
if y == 0:
raise ZeroDivisionError
return llop.ullong_mod(UnsignedLongLong, x, y)
@jit.dont_look_inside
-def ll_lllong_mod(x, y):
+def ll_lllong_py_mod(x, y):
r = llop.lllong_mod(SignedLongLongLong, x, y) # <= truncates like in C
if y < 0: u = -r
else: u = r
return r + (y & (u >> LLLONG_BITS_1))
-def ll_lllong_mod_zer(x, y):
+def ll_lllong_py_mod_zer(x, y):
if y == 0:
raise ZeroDivisionError
- return ll_lllong_mod(x, y)
+ return ll_lllong_py_mod(x, y)
# ---------- lshift, neg, abs ----------
diff --git a/rpython/rtyper/test/test_rint.py b/rpython/rtyper/test/test_rint.py
--- a/rpython/rtyper/test/test_rint.py
+++ b/rpython/rtyper/test/test_rint.py
@@ -390,7 +390,7 @@
res = self.interpret(f, [sys.maxint])
assert res == 0
- def test_int_floordiv_nonnegargs(self):
+ def test_int_py_div_nonnegargs(self):
def f(x, y):
assert x >= 0
assert y >= 0
@@ -398,7 +398,7 @@
res = self.interpret(f, [1234567, 123])
assert res == 1234567 // 123
- def test_int_mod_nonnegargs(self):
+ def test_int_py_mod_nonnegargs(self):
def f(x, y):
assert x >= 0
assert y >= 0
diff --git a/rpython/translator/test/test_simplify.py
b/rpython/translator/test/test_simplify.py
--- a/rpython/translator/test/test_simplify.py
+++ b/rpython/translator/test/test_simplify.py
@@ -55,7 +55,7 @@
graph, _ = translate(f, [int, int], backend_optimize=False)
assert len(graph.startblock.operations) == 1
assert graph.startblock.operations[0].opname == 'direct_call'
- assert 'int_floordiv_ovf_zer' in repr(
+ assert 'int_py_div_ovf_zer' in repr(
graph.startblock.operations[0].args[0].value)
assert len(graph.startblock.exits) == 3
assert [link.target.operations for link in graph.startblock.exits[1:]] == \
@@ -73,7 +73,7 @@
graph, _ = translate(f, [int, int], backend_optimize=False)
assert len(graph.startblock.operations) == 1
assert graph.startblock.operations[0].opname == 'direct_call'
- assert 'int_floordiv_ovf_zer' in repr(
+ assert 'int_py_div_ovf_zer' in repr(
graph.startblock.operations[0].args[0].value)
assert len(graph.startblock.exits) == 3
assert [link.target.operations for link in graph.startblock.exits[1:]] == \
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
