[pypy-commit] pypy callback-jit: merge default
fijal
noreply at buildbot.pypy.org
Mon Dec 31 12:35:35 CET 2012
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: callback-jit
Changeset: r59639:ef9633c66326
Date: 2012-12-31 13:34 +0200
http://bitbucket.org/pypy/pypy/changeset/ef9633c66326/
Log: merge default
diff --git a/lib_pypy/numpypy/core/arrayprint.py b/lib_pypy/numpypy/core/arrayprint.py
--- a/lib_pypy/numpypy/core/arrayprint.py
+++ b/lib_pypy/numpypy/core/arrayprint.py
@@ -248,9 +248,9 @@
'int' : IntegerFormat(data),
'float' : FloatFormat(data, precision, suppress_small),
'longfloat' : LongFloatFormat(precision),
- #'complexfloat' : ComplexFormat(data, precision,
- # suppress_small),
- #'longcomplexfloat' : LongComplexFormat(precision),
+ 'complexfloat' : ComplexFormat(data, precision,
+ suppress_small),
+ 'longcomplexfloat' : LongComplexFormat(precision),
'datetime' : DatetimeFormat(data),
'timedelta' : TimedeltaFormat(data),
'numpystr' : repr_format,
@@ -294,19 +294,19 @@
#else:
format_function = formatdict['int']
elif issubclass(dtypeobj, _nt.floating):
- #if issubclass(dtypeobj, _nt.longfloat):
- # format_function = formatdict['longfloat']
- #else:
- format_function = formatdict['float']
- #elif issubclass(dtypeobj, _nt.complexfloating):
- # if issubclass(dtypeobj, _nt.clongfloat):
- # format_function = formatdict['longcomplexfloat']
- # else:
- # format_function = formatdict['complexfloat']
+ if issubclass(dtypeobj, _nt.longfloat):
+ format_function = formatdict['longfloat']
+ else:
+ format_function = formatdict['float']
+ elif issubclass(dtypeobj, _nt.complexfloating):
+ if issubclass(dtypeobj, _nt.clongfloat):
+ format_function = formatdict['longcomplexfloat']
+ else:
+ format_function = formatdict['complexfloat']
elif issubclass(dtypeobj, (_nt.unicode_, _nt.string_)):
format_function = formatdict['numpystr']
- elif issubclass(dtypeobj, _nt.datetime64):
- format_function = formatdict['datetime']
+ #elif issubclass(dtypeobj, _nt.datetime64):
+ # format_function = formatdict['datetime']
else:
format_function = formatdict['str']
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
--- a/pypy/doc/whatsnew-head.rst
+++ b/pypy/doc/whatsnew-head.rst
@@ -8,8 +8,21 @@
.. branch: length-hint
Implement __lenght_hint__ according to PEP 424
+.. branch: numpypy-longdouble
+Long double support for numpypy
+
+.. branch: signatures
+Improved RPython typing
+
+.. branch: rpython-bytearray
+Rudimentary support for bytearray in RPython
+
.. branches we don't care about
.. branch: autoreds
+.. branch: reflex-support
+.. branch: kill-faking
+.. branch: improved_ebnfparse_error
+.. branch: task-decorator
.. branch: release-2.0-beta1
diff --git a/pypy/jit/backend/arm/assembler.py b/pypy/jit/backend/arm/assembler.py
--- a/pypy/jit/backend/arm/assembler.py
+++ b/pypy/jit/backend/arm/assembler.py
@@ -8,7 +8,7 @@
from pypy.jit.backend.arm.codebuilder import ARMv7Builder, OverwritingBuilder
from pypy.jit.backend.arm.locations import get_fp_offset
from pypy.jit.backend.arm.regalloc import (Regalloc, ARMFrameManager,
- ARMv7RegisterManager, check_imm_arg,
+ CoreRegisterManager, check_imm_arg,
operations as regalloc_operations,
operations_with_guard as regalloc_operations_with_guard)
from pypy.jit.backend.llsupport.asmmemmgr import MachineDataBlockWrapper
@@ -492,10 +492,10 @@
# are stored in r0 and r1.
mc.SUB_rr(r.r0.value, r.r1.value, r.r0.value)
addr = self.cpu.gc_ll_descr.get_malloc_slowpath_addr()
- for reg, ofs in ARMv7RegisterManager.REGLOC_TO_COPY_AREA_OFS.items():
+ for reg, ofs in CoreRegisterManager.REGLOC_TO_COPY_AREA_OFS.items():
mc.STR_ri(reg.value, r.fp.value, imm=ofs)
mc.BL(addr)
- for reg, ofs in ARMv7RegisterManager.REGLOC_TO_COPY_AREA_OFS.items():
+ for reg, ofs in CoreRegisterManager.REGLOC_TO_COPY_AREA_OFS.items():
mc.LDR_ri(reg.value, r.fp.value, imm=ofs)
mc.CMP_ri(r.r0.value, 0)
diff --git a/pypy/jit/backend/arm/helper/regalloc.py b/pypy/jit/backend/arm/helper/regalloc.py
--- a/pypy/jit/backend/arm/helper/regalloc.py
+++ b/pypy/jit/backend/arm/helper/regalloc.py
@@ -32,14 +32,14 @@
imm_a0 = check_imm_box(a0, imm_size, allow_zero=allow_zero)
imm_a1 = check_imm_box(a1, imm_size, allow_zero=allow_zero)
if not imm_a0 and imm_a1:
- l0 = self._ensure_value_is_boxed(a0)
+ l0 = self.make_sure_var_in_reg(a0)
l1 = self.convert_to_imm(a1)
elif commutative and imm_a0 and not imm_a1:
l1 = self.convert_to_imm(a0)
- l0 = self._ensure_value_is_boxed(a1, boxes)
+ l0 = self.make_sure_var_in_reg(a1, boxes)
else:
- l0 = self._ensure_value_is_boxed(a0, boxes)
- l1 = self._ensure_value_is_boxed(a1, boxes)
+ l0 = self.make_sure_var_in_reg(a0, boxes)
+ l1 = self.make_sure_var_in_reg(a1, boxes)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
res = self.force_allocate_reg(op.result, boxes)
@@ -52,10 +52,10 @@
if guard:
def f(self, op, guard_op, fcond):
locs = []
- loc1 = self._ensure_value_is_boxed(op.getarg(0))
+ loc1 = self.make_sure_var_in_reg(op.getarg(0))
locs.append(loc1)
if base:
- loc2 = self._ensure_value_is_boxed(op.getarg(1))
+ loc2 = self.make_sure_var_in_reg(op.getarg(1))
locs.append(loc2)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
@@ -70,10 +70,10 @@
else:
def f(self, op, fcond):
locs = []
- loc1 = self._ensure_value_is_boxed(op.getarg(0))
+ loc1 = self.make_sure_var_in_reg(op.getarg(0))
locs.append(loc1)
if base:
- loc2 = self._ensure_value_is_boxed(op.getarg(1))
+ loc2 = self.make_sure_var_in_reg(op.getarg(1))
locs.append(loc2)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
@@ -111,11 +111,11 @@
arg0, arg1 = boxes
imm_a1 = check_imm_box(arg1)
- l0 = self._ensure_value_is_boxed(arg0, forbidden_vars=boxes)
+ l0 = self.make_sure_var_in_reg(arg0, forbidden_vars=boxes)
if imm_a1:
l1 = self.convert_to_imm(arg1)
else:
- l1 = self._ensure_value_is_boxed(arg1, forbidden_vars=boxes)
+ l1 = self.make_sure_var_in_reg(arg1, forbidden_vars=boxes)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
@@ -134,7 +134,7 @@
assert fcond is not None
a0 = op.getarg(0)
assert isinstance(a0, Box)
- reg = self._ensure_value_is_boxed(a0)
+ reg = self.make_sure_var_in_reg(a0)
self.possibly_free_vars_for_op(op)
if guard_op is None:
res = self.force_allocate_reg(op.result, [a0])
diff --git a/pypy/jit/backend/arm/opassembler.py b/pypy/jit/backend/arm/opassembler.py
--- a/pypy/jit/backend/arm/opassembler.py
+++ b/pypy/jit/backend/arm/opassembler.py
@@ -988,8 +988,8 @@
def _emit_copystrcontent(self, op, regalloc, fcond, is_unicode):
# compute the source address
args = op.getarglist()
- base_loc = regalloc._ensure_value_is_boxed(args[0], args)
- ofs_loc = regalloc._ensure_value_is_boxed(args[2], args)
+ base_loc = regalloc.make_sure_var_in_reg(args[0], args)
+ ofs_loc = regalloc.make_sure_var_in_reg(args[2], args)
assert args[0] is not args[1] # forbidden case of aliasing
regalloc.possibly_free_var(args[0])
regalloc.free_temp_vars()
@@ -1009,8 +1009,8 @@
dstaddr_loc = regalloc.force_allocate_reg(dstaddr_box,
selected_reg=r.r0)
forbidden_vars.append(dstaddr_box)
- base_loc = regalloc._ensure_value_is_boxed(args[1], forbidden_vars)
- ofs_loc = regalloc._ensure_value_is_boxed(args[3], forbidden_vars)
+ base_loc = regalloc.make_sure_var_in_reg(args[1], forbidden_vars)
+ ofs_loc = regalloc.make_sure_var_in_reg(args[3], forbidden_vars)
assert base_loc.is_reg()
assert ofs_loc.is_reg()
regalloc.possibly_free_var(args[1])
@@ -1026,7 +1026,7 @@
# need the box here
if isinstance(args[4], Box):
length_box = args[4]
- length_loc = regalloc._ensure_value_is_boxed(args[4],
+ length_loc = regalloc.make_sure_var_in_reg(args[4],
forbidden_vars)
else:
length_box = TempInt()
diff --git a/pypy/jit/backend/arm/regalloc.py b/pypy/jit/backend/arm/regalloc.py
--- a/pypy/jit/backend/arm/regalloc.py
+++ b/pypy/jit/backend/arm/regalloc.py
@@ -84,8 +84,28 @@
def void(self, op, fcond):
return []
+class ARMRegisterManager(RegisterManager):
+ def return_constant(self, v, forbidden_vars=[], selected_reg=None):
+ self._check_type(v)
+ if isinstance(v, Const):
+ if isinstance(v, ConstPtr):
+ tp = REF
+ elif isinstance(v, ConstFloat):
+ tp = FLOAT
+ else:
+ tp = INT
+ loc = self.get_scratch_reg(tp,
+ self.temp_boxes + forbidden_vars,
+ selected_reg=selected_reg)
+ immvalue = self.convert_to_imm(v)
+ self.assembler.load(loc, immvalue)
+ return loc
+ else:
+ return RegisterManager.return_constant(self, v,
+ forbidden_vars, selected_reg)
-class VFPRegisterManager(RegisterManager):
+
+class VFPRegisterManager(ARMRegisterManager):
all_regs = r.all_vfp_regs
box_types = [FLOAT]
save_around_call_regs = r.all_vfp_regs
@@ -107,20 +127,7 @@
reg = self.force_allocate_reg(v, selected_reg=r.d0)
return reg
- def ensure_value_is_boxed(self, thing, forbidden_vars=[]):
- loc = None
- if isinstance(thing, Const):
- assert isinstance(thing, ConstFloat)
- loc = self.get_scratch_reg(FLOAT, self.temp_boxes + forbidden_vars)
- immvalue = self.convert_to_imm(thing)
- self.assembler.load(loc, immvalue)
- else:
- loc = self.make_sure_var_in_reg(thing,
- forbidden_vars=self.temp_boxes + forbidden_vars)
- return loc
-
- def get_scratch_reg(self, type=FLOAT, forbidden_vars=[],
- selected_reg=None):
+ def get_scratch_reg(self, type=FLOAT, forbidden_vars=[], selected_reg=None):
assert type == FLOAT # for now
box = TempFloat()
self.temp_boxes.append(box)
@@ -129,7 +136,7 @@
return reg
-class ARMv7RegisterManager(RegisterManager):
+class CoreRegisterManager(ARMRegisterManager):
all_regs = r.all_regs
box_types = None # or a list of acceptable types
no_lower_byte_regs = all_regs
@@ -162,22 +169,6 @@
return locations.ImmLocation(rffi.cast(lltype.Signed, c.value))
assert 0
- def ensure_value_is_boxed(self, thing, forbidden_vars=None):
- loc = None
- if isinstance(thing, Const):
- if isinstance(thing, ConstPtr):
- tp = REF
- else:
- tp = INT
- loc = self.get_scratch_reg(tp, forbidden_vars=self.temp_boxes
- + forbidden_vars)
- immvalue = self.convert_to_imm(thing)
- self.assembler.load(loc, immvalue)
- else:
- loc = self.make_sure_var_in_reg(thing,
- forbidden_vars=self.temp_boxes + forbidden_vars)
- return loc
-
def get_scratch_reg(self, type=INT, forbidden_vars=[], selected_reg=None):
assert type == INT or type == REF
box = TempBox()
@@ -277,7 +268,12 @@
def make_sure_var_in_reg(self, var, forbidden_vars=[],
selected_reg=None, need_lower_byte=False):
- assert 0, 'should not be called directly'
+ if var.type == FLOAT:
+ return self.vfprm.make_sure_var_in_reg(var, forbidden_vars,
+ selected_reg, need_lower_byte)
+ else:
+ return self.rm.make_sure_var_in_reg(var, forbidden_vars,
+ selected_reg, need_lower_byte)
def convert_to_imm(self, value):
if isinstance(value, ConstInt):
@@ -294,7 +290,7 @@
fm = self.frame_manager
asm = self.assembler
self.vfprm = VFPRegisterManager(longevity, fm, asm)
- self.rm = ARMv7RegisterManager(longevity, fm, asm)
+ self.rm = CoreRegisterManager(longevity, fm, asm)
def prepare_loop(self, inputargs, operations):
self._prepare(inputargs, operations)
@@ -426,12 +422,6 @@
self.rm.before_call(force_store, save_all_regs)
self.vfprm.before_call(force_store, save_all_regs)
- def _ensure_value_is_boxed(self, thing, forbidden_vars=[]):
- if thing.type == FLOAT:
- return self.vfprm.ensure_value_is_boxed(thing, forbidden_vars)
- else:
- return self.rm.ensure_value_is_boxed(thing, forbidden_vars)
-
def _sync_var(self, v):
if v.type == FLOAT:
self.vfprm._sync_var(v)
@@ -444,14 +434,14 @@
imm_a0 = check_imm_box(a0)
imm_a1 = check_imm_box(a1)
if not imm_a0 and imm_a1:
- l0 = self._ensure_value_is_boxed(a0, boxes)
+ l0 = self.make_sure_var_in_reg(a0, boxes)
l1 = self.convert_to_imm(a1)
elif imm_a0 and not imm_a1:
l0 = self.convert_to_imm(a0)
- l1 = self._ensure_value_is_boxed(a1, boxes)
+ l1 = self.make_sure_var_in_reg(a1, boxes)
else:
- l0 = self._ensure_value_is_boxed(a0, boxes)
- l1 = self._ensure_value_is_boxed(a1, boxes)
+ l0 = self.make_sure_var_in_reg(a0, boxes)
+ l1 = self.make_sure_var_in_reg(a1, boxes)
return [l0, l1]
def prepare_op_int_add(self, op, fcond):
@@ -466,14 +456,14 @@
imm_a0 = check_imm_box(a0)
imm_a1 = check_imm_box(a1)
if not imm_a0 and imm_a1:
- l0 = self._ensure_value_is_boxed(a0, boxes)
+ l0 = self.make_sure_var_in_reg(a0, boxes)
l1 = self.convert_to_imm(a1)
elif imm_a0 and not imm_a1:
l0 = self.convert_to_imm(a0)
- l1 = self._ensure_value_is_boxed(a1, boxes)
+ l1 = self.make_sure_var_in_reg(a1, boxes)
else:
- l0 = self._ensure_value_is_boxed(a0, boxes)
- l1 = self._ensure_value_is_boxed(a1, boxes)
+ l0 = self.make_sure_var_in_reg(a0, boxes)
+ l1 = self.make_sure_var_in_reg(a1, boxes)
return [l0, l1]
def prepare_op_int_sub(self, op, fcond):
@@ -487,8 +477,8 @@
boxes = op.getarglist()
a0, a1 = boxes
- reg1 = self._ensure_value_is_boxed(a0, forbidden_vars=boxes)
- reg2 = self._ensure_value_is_boxed(a1, forbidden_vars=boxes)
+ reg1 = self.make_sure_var_in_reg(a0, forbidden_vars=boxes)
+ reg2 = self.make_sure_var_in_reg(a1, forbidden_vars=boxes)
self.possibly_free_vars(boxes)
self.possibly_free_vars_for_op(op)
@@ -497,14 +487,14 @@
return [reg1, reg2, res]
def prepare_op_int_force_ge_zero(self, op, fcond):
- argloc = self._ensure_value_is_boxed(op.getarg(0))
+ argloc = self.make_sure_var_in_reg(op.getarg(0))
resloc = self.force_allocate_reg(op.result, [op.getarg(0)])
return [argloc, resloc]
def prepare_guard_int_mul_ovf(self, op, guard, fcond):
boxes = op.getarglist()
- reg1 = self._ensure_value_is_boxed(boxes[0], forbidden_vars=boxes)
- reg2 = self._ensure_value_is_boxed(boxes[1], forbidden_vars=boxes)
+ reg1 = self.make_sure_var_in_reg(boxes[0], forbidden_vars=boxes)
+ reg2 = self.make_sure_var_in_reg(boxes[1], forbidden_vars=boxes)
res = self.force_allocate_reg(op.result)
return self._prepare_guard(guard, [reg1, reg2, res])
@@ -576,7 +566,7 @@
prepare_guard_int_is_zero = prepare_op_unary_cmp('int_is_zero')
def prepare_op_int_neg(self, op, fcond):
- l0 = self._ensure_value_is_boxed(op.getarg(0))
+ l0 = self.make_sure_var_in_reg(op.getarg(0))
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
resloc = self.force_allocate_reg(op.result)
@@ -629,15 +619,15 @@
def _prepare_llong_binop_xx(self, op, fcond):
# arg 0 is the address of the function
- loc0 = self._ensure_value_is_boxed(op.getarg(1))
- loc1 = self._ensure_value_is_boxed(op.getarg(2))
+ loc0 = self.make_sure_var_in_reg(op.getarg(1))
+ loc1 = self.make_sure_var_in_reg(op.getarg(2))
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
res = self.vfprm.force_allocate_reg(op.result)
return [loc0, loc1, res]
def _prepare_llong_to_int(self, op, fcond):
- loc0 = self._ensure_value_is_boxed(op.getarg(1))
+ loc0 = self.make_sure_var_in_reg(op.getarg(1))
res = self.force_allocate_reg(op.result)
return [loc0, res]
@@ -665,7 +655,7 @@
return args
def prepare_op_guard_true(self, op, fcond):
- l0 = self._ensure_value_is_boxed(op.getarg(0))
+ l0 = self.make_sure_var_in_reg(op.getarg(0))
args = self._prepare_guard(op, [l0])
return args
@@ -677,9 +667,9 @@
boxes = op.getarglist()
a0, a1 = boxes
imm_a1 = check_imm_box(a1)
- l0 = self._ensure_value_is_boxed(a0, boxes)
+ l0 = self.make_sure_var_in_reg(a0, boxes)
if not imm_a1:
- l1 = self._ensure_value_is_boxed(a1, boxes)
+ l1 = self.make_sure_var_in_reg(a1, boxes)
else:
l1 = self.convert_to_imm(a1)
assert op.result is None
@@ -699,7 +689,7 @@
def prepare_op_guard_exception(self, op, fcond):
boxes = op.getarglist()
arg0 = ConstInt(rffi.cast(lltype.Signed, op.getarg(0).getint()))
- loc = self._ensure_value_is_boxed(arg0)
+ loc = self.make_sure_var_in_reg(arg0)
loc1 = self.get_scratch_reg(INT, boxes)
if op.result in self.longevity:
resloc = self.force_allocate_reg(op.result, boxes)
@@ -713,7 +703,7 @@
return arglocs
def prepare_op_guard_no_exception(self, op, fcond):
- loc = self._ensure_value_is_boxed(
+ loc = self.make_sure_var_in_reg(
ConstInt(self.cpu.pos_exception()))
arglocs = self._prepare_guard(op, [loc])
return arglocs
@@ -727,7 +717,7 @@
assert isinstance(op.getarg(0), Box)
boxes = op.getarglist()
- x = self._ensure_value_is_boxed(boxes[0], boxes)
+ x = self.make_sure_var_in_reg(boxes[0], boxes)
y_val = rffi.cast(lltype.Signed, op.getarg(1).getint())
arglocs = [x, None, None]
@@ -837,8 +827,8 @@
boxes = op.getarglist()
a0, a1 = boxes
ofs, size, sign = unpack_fielddescr(op.getdescr())
- base_loc = self._ensure_value_is_boxed(a0, boxes)
- value_loc = self._ensure_value_is_boxed(a1, boxes)
+ base_loc = self.make_sure_var_in_reg(a0, boxes)
+ value_loc = self.make_sure_var_in_reg(a1, boxes)
if check_imm_arg(ofs):
ofs_loc = imm(ofs)
else:
@@ -851,7 +841,7 @@
def prepare_op_getfield_gc(self, op, fcond):
a0 = op.getarg(0)
ofs, size, sign = unpack_fielddescr(op.getdescr())
- base_loc = self._ensure_value_is_boxed(a0)
+ base_loc = self.make_sure_var_in_reg(a0)
immofs = imm(ofs)
if check_imm_arg(ofs):
ofs_loc = immofs
@@ -871,8 +861,8 @@
t = unpack_interiorfielddescr(op.getdescr())
ofs, itemsize, fieldsize, sign = t
args = op.getarglist()
- base_loc = self._ensure_value_is_boxed(op.getarg(0), args)
- index_loc = self._ensure_value_is_boxed(op.getarg(1), args)
+ base_loc = self.make_sure_var_in_reg(op.getarg(0), args)
+ index_loc = self.make_sure_var_in_reg(op.getarg(1), args)
immofs = imm(ofs)
if check_imm_arg(ofs):
ofs_loc = immofs
@@ -889,9 +879,9 @@
t = unpack_interiorfielddescr(op.getdescr())
ofs, itemsize, fieldsize, sign = t
args = op.getarglist()
- base_loc = self._ensure_value_is_boxed(op.getarg(0), args)
- index_loc = self._ensure_value_is_boxed(op.getarg(1), args)
- value_loc = self._ensure_value_is_boxed(op.getarg(2), args)
+ base_loc = self.make_sure_var_in_reg(op.getarg(0), args)
+ index_loc = self.make_sure_var_in_reg(op.getarg(1), args)
+ value_loc = self.make_sure_var_in_reg(op.getarg(2), args)
immofs = imm(ofs)
if check_imm_arg(ofs):
ofs_loc = immofs
@@ -907,7 +897,7 @@
assert isinstance(arraydescr, ArrayDescr)
ofs = arraydescr.lendescr.offset
arg = op.getarg(0)
- base_loc = self._ensure_value_is_boxed(arg)
+ base_loc = self.make_sure_var_in_reg(arg)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
res = self.force_allocate_reg(op.result)
@@ -917,9 +907,9 @@
size, ofs, _ = unpack_arraydescr(op.getdescr())
scale = get_scale(size)
args = op.getarglist()
- base_loc = self._ensure_value_is_boxed(args[0], args)
- ofs_loc = self._ensure_value_is_boxed(args[1], args)
- value_loc = self._ensure_value_is_boxed(args[2], args)
+ base_loc = self.make_sure_var_in_reg(args[0], args)
+ ofs_loc = self.make_sure_var_in_reg(args[1], args)
+ value_loc = self.make_sure_var_in_reg(args[2], args)
assert check_imm_arg(ofs)
return [value_loc, base_loc, ofs_loc, imm(scale), imm(ofs)]
prepare_op_setarrayitem_raw = prepare_op_setarrayitem_gc
@@ -929,8 +919,8 @@
boxes = op.getarglist()
size, ofs, _ = unpack_arraydescr(op.getdescr())
scale = get_scale(size)
- base_loc = self._ensure_value_is_boxed(boxes[0], boxes)
- ofs_loc = self._ensure_value_is_boxed(boxes[1], boxes)
+ base_loc = self.make_sure_var_in_reg(boxes[0], boxes)
+ ofs_loc = self.make_sure_var_in_reg(boxes[1], boxes)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
res = self.force_allocate_reg(op.result)
@@ -944,7 +934,7 @@
def prepare_op_strlen(self, op, fcond):
args = op.getarglist()
- l0 = self._ensure_value_is_boxed(op.getarg(0))
+ l0 = self.make_sure_var_in_reg(op.getarg(0))
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.STR,
self.cpu.translate_support_code)
immofs = imm(ofs_length)
@@ -963,14 +953,14 @@
def prepare_op_strgetitem(self, op, fcond):
boxes = op.getarglist()
- base_loc = self._ensure_value_is_boxed(boxes[0])
+ base_loc = self.make_sure_var_in_reg(boxes[0])
a1 = boxes[1]
imm_a1 = check_imm_box(a1)
if imm_a1:
ofs_loc = self.convert_to_imm(a1)
else:
- ofs_loc = self._ensure_value_is_boxed(a1, boxes)
+ ofs_loc = self.make_sure_var_in_reg(a1, boxes)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
@@ -983,9 +973,9 @@
def prepare_op_strsetitem(self, op, fcond):
boxes = op.getarglist()
- base_loc = self._ensure_value_is_boxed(boxes[0], boxes)
- ofs_loc = self._ensure_value_is_boxed(boxes[1], boxes)
- value_loc = self._ensure_value_is_boxed(boxes[2], boxes)
+ base_loc = self.make_sure_var_in_reg(boxes[0], boxes)
+ ofs_loc = self.make_sure_var_in_reg(boxes[1], boxes)
+ value_loc = self.make_sure_var_in_reg(boxes[2], boxes)
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.STR,
self.cpu.translate_support_code)
assert itemsize == 1
@@ -995,7 +985,7 @@
prepare_op_copyunicodecontent = void
def prepare_op_unicodelen(self, op, fcond):
- l0 = self._ensure_value_is_boxed(op.getarg(0))
+ l0 = self.make_sure_var_in_reg(op.getarg(0))
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.UNICODE,
self.cpu.translate_support_code)
immofs = imm(ofs_length)
@@ -1012,8 +1002,8 @@
def prepare_op_unicodegetitem(self, op, fcond):
boxes = op.getarglist()
- base_loc = self._ensure_value_is_boxed(boxes[0], boxes)
- ofs_loc = self._ensure_value_is_boxed(boxes[1], boxes)
+ base_loc = self.make_sure_var_in_reg(boxes[0], boxes)
+ ofs_loc = self.make_sure_var_in_reg(boxes[1], boxes)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
@@ -1027,9 +1017,9 @@
def prepare_op_unicodesetitem(self, op, fcond):
boxes = op.getarglist()
- base_loc = self._ensure_value_is_boxed(boxes[0], boxes)
- ofs_loc = self._ensure_value_is_boxed(boxes[1], boxes)
- value_loc = self._ensure_value_is_boxed(boxes[2], boxes)
+ base_loc = self.make_sure_var_in_reg(boxes[0], boxes)
+ ofs_loc = self.make_sure_var_in_reg(boxes[1], boxes)
+ value_loc = self.make_sure_var_in_reg(boxes[2], boxes)
basesize, itemsize, ofs_length = symbolic.get_array_token(rstr.UNICODE,
self.cpu.translate_support_code)
scale = itemsize / 2
@@ -1042,7 +1032,7 @@
if imm_arg:
argloc = self.convert_to_imm(arg)
else:
- argloc = self._ensure_value_is_boxed(arg)
+ argloc = self.make_sure_var_in_reg(arg)
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
resloc = self.force_allocate_reg(op.result)
@@ -1093,7 +1083,7 @@
# twice from the memory.
N = op.numargs()
args = op.getarglist()
- arglocs = [self._ensure_value_is_boxed(op.getarg(i), args)
+ arglocs = [self.make_sure_var_in_reg(op.getarg(i), args)
for i in range(N)]
tmp = self.get_scratch_reg(INT, args)
assert tmp not in arglocs
@@ -1215,7 +1205,7 @@
float_result=False, name='prepare_guard_float_ge')
def prepare_op_math_sqrt(self, op, fcond):
- loc = self._ensure_value_is_boxed(op.getarg(1))
+ loc = self.make_sure_var_in_reg(op.getarg(1))
self.possibly_free_vars_for_op(op)
self.free_temp_vars()
res = self.vfprm.force_allocate_reg(op.result)
@@ -1223,12 +1213,12 @@
return [loc, res]
def prepare_op_cast_float_to_int(self, op, fcond):
- loc1 = self._ensure_value_is_boxed(op.getarg(0))
+ loc1 = self.make_sure_var_in_reg(op.getarg(0))
res = self.rm.force_allocate_reg(op.result)
return [loc1, res]
def prepare_op_cast_int_to_float(self, op, fcond):
- loc1 = self._ensure_value_is_boxed(op.getarg(0))
+ loc1 = self.make_sure_var_in_reg(op.getarg(0))
res = self.vfprm.force_allocate_reg(op.result)
return [loc1, res]
@@ -1247,12 +1237,12 @@
return [loc, res]
def prepare_op_cast_float_to_singlefloat(self, op, fcond):
- loc1 = self._ensure_value_is_boxed(op.getarg(0))
+ loc1 = self.make_sure_var_in_reg(op.getarg(0))
res = self.force_allocate_reg(op.result)
return [loc1, res]
-
+
def prepare_op_cast_singlefloat_to_float(self, op, fcond):
- loc1 = self._ensure_value_is_boxed(op.getarg(0))
+ loc1 = self.make_sure_var_in_reg(op.getarg(0))
res = self.force_allocate_reg(op.result)
return [loc1, res]
diff --git a/pypy/jit/backend/arm/test/test_gc_integration.py b/pypy/jit/backend/arm/test/test_gc_integration.py
--- a/pypy/jit/backend/arm/test/test_gc_integration.py
+++ b/pypy/jit/backend/arm/test/test_gc_integration.py
@@ -20,7 +20,7 @@
from pypy.jit.backend.arm.test.test_regalloc import BaseTestRegalloc
from pypy.jit.backend.arm.regalloc import ARMFrameManager, VFPRegisterManager
from pypy.jit.codewriter.effectinfo import EffectInfo
-from pypy.jit.backend.arm.regalloc import Regalloc, ARMv7RegisterManager
+from pypy.jit.backend.arm.regalloc import Regalloc
CPU = getcpuclass()
diff --git a/pypy/jit/backend/llsupport/regalloc.py b/pypy/jit/backend/llsupport/regalloc.py
--- a/pypy/jit/backend/llsupport/regalloc.py
+++ b/pypy/jit/backend/llsupport/regalloc.py
@@ -479,7 +479,7 @@
"""
raise NotImplementedError("Abstract")
- def get_scratch_reg(self, forbidden_vars=[]):
+ def get_scratch_reg(self, type, forbidden_vars=[], selected_reg=None):
""" Platform specific - Allocates a temporary register """
raise NotImplementedError("Abstract")
diff --git a/pypy/jit/codewriter/jtransform.py b/pypy/jit/codewriter/jtransform.py
--- a/pypy/jit/codewriter/jtransform.py
+++ b/pypy/jit/codewriter/jtransform.py
@@ -304,6 +304,8 @@
rewrite_op_convert_float_bytes_to_longlong = _noop_rewrite
rewrite_op_convert_longlong_bytes_to_float = _noop_rewrite
+ cast_ptr_to_weakrefptr = _noop_rewrite
+ cast_weakrefptr_to_ptr = _noop_rewrite
# ----------
# Various kinds of calls
@@ -450,6 +452,7 @@
resulttype, extra, extrakey)
return SpaceOperation('direct_call', [c_func] + args, op.result)
+
def _do_builtin_call(self, op, oopspec_name=None, args=None,
extra=None, extrakey=None):
if oopspec_name is None: oopspec_name = op.opname
@@ -482,6 +485,9 @@
rewrite_op_uint_mod = _do_builtin_call
rewrite_op_cast_float_to_uint = _do_builtin_call
rewrite_op_cast_uint_to_float = _do_builtin_call
+ rewrite_op_weakref_create = _do_builtin_call
+ rewrite_op_weakref_deref = _do_builtin_call
+ rewrite_op_gc_add_memory_pressure = _do_builtin_call
# ----------
# getfield/setfield/mallocs etc.
diff --git a/pypy/jit/codewriter/support.py b/pypy/jit/codewriter/support.py
--- a/pypy/jit/codewriter/support.py
+++ b/pypy/jit/codewriter/support.py
@@ -1,15 +1,13 @@
import sys
-from pypy.rpython.lltypesystem import lltype, rclass, rffi
+from pypy.rpython.lltypesystem import lltype, rclass, rffi, llmemory
from pypy.rpython.ootypesystem import ootype
from pypy.rpython import rlist
from pypy.rpython.lltypesystem import rstr as ll_rstr, rdict as ll_rdict
-from pypy.rpython.lltypesystem import rlist as lltypesystem_rlist
from pypy.rpython.lltypesystem.module import ll_math
from pypy.rpython.lltypesystem.lloperation import llop
from pypy.rpython.ootypesystem import rdict as oo_rdict
from pypy.rpython.llinterp import LLInterpreter
from pypy.rpython.extregistry import ExtRegistryEntry
-from pypy.rpython.annlowlevel import cast_base_ptr_to_instance
from pypy.translator.simplify import get_funcobj
from pypy.translator.unsimplify import split_block
from pypy.objspace.flow.model import Constant
@@ -648,6 +646,15 @@
build_ll_1_raw_free_no_track_allocation = (
build_raw_free_builder(track_allocation=False))
+ def _ll_1_weakref_create(obj):
+ return llop.weakref_create(llmemory.WeakRefPtr, obj)
+
+ def _ll_1_weakref_deref(TP, obj):
+ return llop.weakref_deref(lltype.Ptr(TP), obj)
+ _ll_1_weakref_deref.need_result_type = True
+
+ def _ll_1_gc_add_memory_pressure(num):
+ llop.gc_add_memory_pressure(lltype.Void, num)
class OOtypeHelpers:
diff --git a/pypy/jit/metainterp/test/test_ajit.py b/pypy/jit/metainterp/test/test_ajit.py
--- a/pypy/jit/metainterp/test/test_ajit.py
+++ b/pypy/jit/metainterp/test/test_ajit.py
@@ -1,24 +1,19 @@
-import math
import sys
import py
-from pypy import conftest
-from pypy.jit.codewriter import longlong
-from pypy.jit.codewriter.policy import JitPolicy, StopAtXPolicy
-from pypy.jit.metainterp import pyjitpl, history
-from pypy.jit.metainterp.optimizeopt import ALL_OPTS_DICT
+from pypy.jit.codewriter.policy import StopAtXPolicy
+from pypy.jit.metainterp import history
from pypy.jit.metainterp.test.support import LLJitMixin, OOJitMixin, noConst
-from pypy.jit.metainterp.typesystem import LLTypeHelper, OOTypeHelper
from pypy.jit.metainterp.warmspot import get_stats
from pypy.rlib import rerased
from pypy.rlib.jit import (JitDriver, we_are_jitted, hint, dont_look_inside,
loop_invariant, elidable, promote, jit_debug, assert_green,
AssertGreenFailed, unroll_safe, current_trace_length, look_inside_iff,
- isconstant, isvirtual, promote_string, set_param, record_known_class)
+ isconstant, isvirtual, set_param, record_known_class)
from pypy.rlib.longlong2float import float2longlong, longlong2float
from pypy.rlib.rarithmetic import ovfcheck, is_valid_int
-from pypy.rpython.lltypesystem import lltype, llmemory, rffi
+from pypy.rpython.lltypesystem import lltype, rffi
from pypy.rpython.ootypesystem import ootype
@@ -3962,3 +3957,27 @@
return 42
self.interp_operations(f, [1, 2, 3])
self.check_operations_history(call=1, guard_no_exception=0)
+
+ def test_weakref(self):
+ import weakref
+
+ class A(object):
+ def __init__(self, x):
+ self.x = x
+
+ def f(i):
+ a = A(i)
+ w = weakref.ref(a)
+ return w().x + a.x
+
+ assert self.interp_operations(f, [3]) == 6
+
+ def test_gc_add_memory_pressure(self):
+ from pypy.rlib import rgc
+
+ def f():
+ rgc.add_memory_pressure(1234)
+ return 3
+
+ self.interp_operations(f, [])
+
diff --git a/pypy/module/_cffi_backend/ctypeenum.py b/pypy/module/_cffi_backend/ctypeenum.py
--- a/pypy/module/_cffi_backend/ctypeenum.py
+++ b/pypy/module/_cffi_backend/ctypeenum.py
@@ -67,7 +67,7 @@
except OperationError, e:
if not e.match(space, space.w_TypeError):
raise
- if space.isinstance_w(w_ob, space.w_str):
+ if space.isinstance_w(w_ob, space.w_basestring):
value = self.convert_enum_string_to_int(space.str_w(w_ob))
value = r_ulonglong(value)
misc.write_raw_integer_data(cdata, value, self.size)
@@ -78,11 +78,14 @@
space = self.space
return self.convert_enum_string_to_int(space.str_w(w_ob))
+ def cast_unicode(self, w_ob):
+ return self.cast_str(w_ob)
+
def convert_enum_string_to_int(self, s):
space = self.space
if s.startswith('#'):
try:
- return int(s[1:]) # xxx is it RPython?
+ return int(s[1:])
except ValueError:
raise OperationError(space.w_ValueError,
space.wrap("invalid literal after '#'"))
diff --git a/pypy/module/_cffi_backend/test/_backend_test_c.py b/pypy/module/_cffi_backend/test/_backend_test_c.py
--- a/pypy/module/_cffi_backend/test/_backend_test_c.py
+++ b/pypy/module/_cffi_backend/test/_backend_test_c.py
@@ -1309,6 +1309,12 @@
assert p.a1 == "c"
e = py.test.raises(TypeError, newp, BStructPtr, [None])
assert "must be a str or int, not NoneType" in str(e.value)
+ if sys.version_info < (3,):
+ p.a1 = unicode("def")
+ assert p.a1 == "def" and type(p.a1) is str
+ py.test.raises(UnicodeEncodeError, "p.a1 = unichr(1234)")
+ BEnum2 = new_enum_type(unicode("foo"), (unicode('abc'),), (5,))
+ assert string(cast(BEnum2, unicode('abc'))) == 'abc'
def test_enum_overflow():
for ovf in (2**63, -2**63-1, 2**31, -2**31-1):
diff --git a/pypy/module/micronumpy/__init__.py b/pypy/module/micronumpy/__init__.py
--- a/pypy/module/micronumpy/__init__.py
+++ b/pypy/module/micronumpy/__init__.py
@@ -1,4 +1,5 @@
from pypy.interpreter.mixedmodule import MixedModule
+from pypy.module.micronumpy.interp_boxes import long_double_size
class Module(MixedModule):
@@ -58,6 +59,8 @@
'float16': 'interp_boxes.W_Float16Box',
'float32': 'interp_boxes.W_Float32Box',
'float64': 'interp_boxes.W_Float64Box',
+ 'longdouble': 'interp_boxes.W_LongDoubleBox',
+ 'longfloat': 'interp_boxes.W_LongDoubleBox',
'intp': 'types.IntP.BoxType',
'uintp': 'types.UIntP.BoxType',
'flexible': 'interp_boxes.W_FlexibleBox',
@@ -70,6 +73,8 @@
'complex_': 'interp_boxes.W_Complex128Box',
'complex128': 'interp_boxes.W_Complex128Box',
'complex64': 'interp_boxes.W_Complex64Box',
+ 'clongdouble': 'interp_boxes.W_CLongDoubleBox',
+ 'clongfloat': 'interp_boxes.W_CLongDoubleBox',
}
# ufuncs
@@ -163,3 +168,10 @@
'max': 'app_numpy.max',
'arange': 'app_numpy.arange',
}
+
+if long_double_size == 16:
+ Module.interpleveldefs['float128'] = 'interp_boxes.W_Float128Box'
+ Module.interpleveldefs['complex256'] = 'interp_boxes.W_Complex256Box'
+elif long_double_size == 12:
+ Module.interpleveldefs['float96'] = 'interp_boxes.W_Float96Box'
+ Module.interpleveldefs['complex192'] = 'interp_boxes.W_Complex192Box'
diff --git a/pypy/module/micronumpy/interp_boxes.py b/pypy/module/micronumpy/interp_boxes.py
--- a/pypy/module/micronumpy/interp_boxes.py
+++ b/pypy/module/micronumpy/interp_boxes.py
@@ -8,12 +8,20 @@
from pypy.objspace.std.inttype import int_typedef
from pypy.objspace.std.complextype import complex_typedef
from pypy.rlib.rarithmetic import LONG_BIT
+from pypy.rpython.lltypesystem import rffi
from pypy.tool.sourcetools import func_with_new_name
from pypy.module.micronumpy.arrayimpl.voidbox import VoidBoxStorage
MIXIN_32 = (int_typedef,) if LONG_BIT == 32 else ()
MIXIN_64 = (int_typedef,) if LONG_BIT == 64 else ()
+# Is this the proper place for this?
+long_double_size = rffi.sizeof_c_type('long double', ignore_errors=True)
+import os
+if long_double_size == 8 and os.name == 'nt':
+ # this is a lie, or maybe a wish
+ long_double_size = 12
+
def new_dtype_getter(name):
def _get_dtype(space):
@@ -226,7 +234,6 @@
class W_Float64Box(W_FloatingBox, PrimitiveBox):
descr__new__, _get_dtype = new_dtype_getter("float64")
-
class W_FlexibleBox(W_GenericBox):
def __init__(self, arr, ofs, dtype):
self.arr = arr # we have to keep array alive
@@ -315,6 +322,33 @@
descr__new__, _get_dtype = new_dtype_getter("complex128")
_COMPONENTS_BOX = W_Float64Box
+if long_double_size == 12:
+ class W_Float96Box(W_FloatingBox, PrimitiveBox):
+ descr__new__, _get_dtype = new_dtype_getter("float96")
+
+ W_LongDoubleBox = W_Float96Box
+
+ class W_Complex192Box(ComplexBox, W_ComplexFloatingBox):
+ descr__new__, _get_dtype = new_dtype_getter("complex192")
+ _COMPONENTS_BOX = W_Float96Box
+
+ W_CLongDoubleBox = W_Complex192Box
+
+elif long_double_size == 16:
+ class W_Float128Box(W_FloatingBox, PrimitiveBox):
+ descr__new__, _get_dtype = new_dtype_getter("float128")
+ W_LongDoubleBox = W_Float128Box
+
+ class W_Complex256Box(ComplexBox, W_ComplexFloatingBox):
+ descr__new__, _get_dtype = new_dtype_getter("complex256")
+ _COMPONENTS_BOX = W_Float128Box
+
+ W_CLongDoubleBox = W_Complex256Box
+
+else:
+ W_LongDoubleBox = W_Float64Box
+ W_CLongDoubleBox = W_Complex64Box
+
W_GenericBox.typedef = TypeDef("generic",
__module__ = "numpypy",
@@ -479,6 +513,33 @@
__new__ = interp2app(W_Float64Box.descr__new__.im_func),
)
+if long_double_size == 12:
+ W_Float96Box.typedef = TypeDef("float96", (W_FloatingBox.typedef),
+ __module__ = "numpypy",
+
+ __new__ = interp2app(W_Float96Box.descr__new__.im_func),
+ )
+
+ W_Complex192Box.typedef = TypeDef("complex192", (W_ComplexFloatingBox.typedef, complex_typedef),
+ __module__ = "numpypy",
+ __new__ = interp2app(W_Complex192Box.descr__new__.im_func),
+ real = GetSetProperty(W_ComplexFloatingBox.descr_get_real),
+ imag = GetSetProperty(W_ComplexFloatingBox.descr_get_imag),
+ )
+
+elif long_double_size == 16:
+ W_Float128Box.typedef = TypeDef("float128", (W_FloatingBox.typedef),
+ __module__ = "numpypy",
+
+ __new__ = interp2app(W_Float128Box.descr__new__.im_func),
+ )
+
+ W_Complex256Box.typedef = TypeDef("complex256", (W_ComplexFloatingBox.typedef, complex_typedef),
+ __module__ = "numpypy",
+ __new__ = interp2app(W_Complex256Box.descr__new__.im_func),
+ real = GetSetProperty(W_ComplexFloatingBox.descr_get_real),
+ imag = GetSetProperty(W_ComplexFloatingBox.descr_get_imag),
+ )
W_FlexibleBox.typedef = TypeDef("flexible", W_GenericBox.typedef,
__module__ = "numpypy",
diff --git a/pypy/module/micronumpy/interp_dtype.py b/pypy/module/micronumpy/interp_dtype.py
--- a/pypy/module/micronumpy/interp_dtype.py
+++ b/pypy/module/micronumpy/interp_dtype.py
@@ -15,6 +15,7 @@
SIGNEDLTR = "i"
BOOLLTR = "b"
FLOATINGLTR = "f"
+COMPLEXLTR = "c"
VOIDLTR = 'V'
STRINGLTR = 'S'
UNICODELTR = 'U'
@@ -135,7 +136,7 @@
return self.kind == SIGNEDLTR
def is_complex_type(self):
- return (self.num == 14 or self.num == 15)
+ return (self.num == 14 or self.num == 15 or self.num == 16)
def is_bool_type(self):
return self.kind == BOOLLTR
@@ -412,17 +413,10 @@
alternate_constructors=[space.w_float],
aliases=["float"],
)
- # self.w_float128dtype = W_Dtype(
- # types.Float128(),
- # num=13,
- # kind=FLOATINGLTR,
- # name="float128",
- # ...
- # )
self.w_complex64dtype = W_Dtype(
types.Complex64(),
num=14,
- kind=FLOATINGLTR,
+ kind=COMPLEXLTR,
name="complex64",
char="F",
w_box_type = space.gettypefor(interp_boxes.W_Complex64Box),
@@ -430,13 +424,64 @@
self.w_complex128dtype = W_Dtype(
types.Complex128(),
num=15,
- kind=FLOATINGLTR,
+ kind=COMPLEXLTR,
name="complex128",
char="D",
w_box_type = space.gettypefor(interp_boxes.W_Complex128Box),
alternate_constructors=[space.w_complex],
aliases=["complex"],
)
+ if interp_boxes.long_double_size == 12:
+ self.w_float96dtype = W_Dtype(
+ types.Float96(),
+ num=13,
+ kind=FLOATINGLTR,
+ name="float96",
+ char="g",
+ w_box_type=space.gettypefor(interp_boxes.W_Float96Box),
+ aliases=["longfloat", "longdouble"],
+ )
+ self.w_longdouble = self.w_float96dtype
+
+ self.w_complex192dtype = W_Dtype(
+ types.Complex192(),
+ num=16,
+ kind=COMPLEXLTR,
+ name="complex192",
+ char="G",
+ w_box_type = space.gettypefor(interp_boxes.W_Complex192Box),
+ alternate_constructors=[space.w_complex],
+ aliases=["clongdouble", "clongfloat"],
+ )
+ self.w_clongdouble = self.w_complex192dtype
+
+ elif interp_boxes.long_double_size == 16:
+ self.w_float128dtype = W_Dtype(
+ types.Float128(),
+ num=13,
+ kind=FLOATINGLTR,
+ name="float128",
+ char="g",
+ w_box_type=space.gettypefor(interp_boxes.W_Float128Box),
+ aliases=["longfloat", "longdouble"],
+ )
+ self.w_longdouble = self.w_float128dtype
+
+ self.w_complex256dtype = W_Dtype(
+ types.Complex256(),
+ num=16,
+ kind=COMPLEXLTR,
+ name="complex256",
+ char="G",
+ w_box_type = space.gettypefor(interp_boxes.W_Complex256Box),
+ alternate_constructors=[space.w_complex],
+ aliases=["clongdouble", "clongfloat"],
+ )
+ self.w_clongdouble = self.w_complex256dtype
+ else:
+ self.w_float64dtype.aliases += ["longfloat", "longdouble"]
+ self.w_longdouble = self.w_float64dtype
+ self.w_clongdouble = self.w_complex64dtype
self.w_stringdtype = W_Dtype(
types.StringType(1),
num=18,
@@ -507,14 +552,16 @@
self.w_int16dtype, self.w_uint16dtype, self.w_int32dtype,
self.w_uint32dtype, self.w_longdtype, self.w_ulongdtype,
self.w_int64dtype, self.w_uint64dtype,
- self.w_float16dtype, self.w_float32dtype, self.w_float64dtype, self.w_complex64dtype,
- self.w_complex128dtype,
+ self.w_float16dtype, self.w_float32dtype, self.w_float64dtype,
+ self.w_longdouble,
+ self.w_complex64dtype, self.w_complex128dtype, self.w_clongdouble,
self.w_stringdtype, self.w_unicodedtype,
self.w_voiddtype, self.w_intpdtype, self.w_uintpdtype,
]
self.float_dtypes_by_num_bytes = sorted(
(dtype.itemtype.get_element_size(), dtype)
- for dtype in [self.w_float16dtype, self.w_float32dtype, self.w_float64dtype]
+ for dtype in [self.w_float16dtype, self.w_float32dtype,
+ self.w_float64dtype, self.w_longdouble]
)
self.dtypes_by_name = {}
# we reverse, so the stuff with lower numbers override stuff with
@@ -540,7 +587,7 @@
'LONGLONG': self.w_int64dtype,
'SHORT': self.w_int16dtype,
'VOID': self.w_voiddtype,
- #'LONGDOUBLE':,
+ 'LONGDOUBLE': self.w_longdouble,
'UBYTE': self.w_uint8dtype,
'UINTP': self.w_ulongdtype,
'ULONG': self.w_ulongdtype,
@@ -549,7 +596,7 @@
#'OBJECT',
'ULONGLONG': self.w_uint64dtype,
'STRING': self.w_stringdtype,
- #'CDOUBLE',
+ 'CDOUBLE': self.w_complex64dtype,
#'DATETIME',
'UINT': self.w_uint32dtype,
'INTP': self.w_intpdtype,
@@ -563,7 +610,7 @@
'USHORT': self.w_uint16dtype,
'FLOAT': self.w_float32dtype,
'BOOL': self.w_booldtype,
- #, 'CLONGDOUBLE']
+ 'CLONGDOUBLE': self.w_clongdouble,
}
typeinfo_partial = {
'Generic': interp_boxes.W_GenericBox,
@@ -573,7 +620,7 @@
'Integer': interp_boxes.W_IntegerBox,
'SignedInteger': interp_boxes.W_SignedIntegerBox,
'UnsignedInteger': interp_boxes.W_UnsignedIntegerBox,
- #'ComplexFloating',
+ 'ComplexFloating': interp_boxes.W_ComplexFloatingBox,
'Number': interp_boxes.W_NumberBox,
'Floating': interp_boxes.W_FloatingBox
}
diff --git a/pypy/module/micronumpy/interp_ufuncs.py b/pypy/module/micronumpy/interp_ufuncs.py
--- a/pypy/module/micronumpy/interp_ufuncs.py
+++ b/pypy/module/micronumpy/interp_ufuncs.py
@@ -375,12 +375,17 @@
if promote_bools and (dt1.kind == dt2.kind == interp_dtype.BOOLLTR):
return interp_dtype.get_dtype_cache(space).w_int8dtype
- # Everything promotes to complex
- if dt2.num == 14 or dt2.num == 15 or dt1.num == 14 or dt2.num == 15:
- if dt2.num == 15 or dt1.num == 15:
+ # Everything numeric promotes to complex
+ if dt2.is_complex_type() or dt1.is_complex_type():
+ if dt2.num == 14:
+ return interp_dtype.get_dtype_cache(space).w_complex64dtype
+ elif dt2.num == 15:
return interp_dtype.get_dtype_cache(space).w_complex128dtype
+ elif dt2.num == 16:
+ return interp_dtype.get_dtype_cache(space).w_clongdouble
else:
- return interp_dtype.get_dtype_cache(space).w_complex64dtype
+ raise OperationError(space.w_TypeError, space.wrap("Unsupported types"))
+
if promote_to_float:
return find_unaryop_result_dtype(space, dt2, promote_to_float=True)
@@ -431,7 +436,7 @@
if not allow_complex and (dt.is_complex_type()):
raise OperationError(space.w_TypeError, space.wrap("Unsupported types"))
if promote_to_float:
- if dt.kind == interp_dtype.FLOATINGLTR:
+ if dt.kind == interp_dtype.FLOATINGLTR or dt.kind==interp_dtype.COMPLEXLTR:
return dt
if dt.num >= 5:
return interp_dtype.get_dtype_cache(space).w_float64dtype
diff --git a/pypy/module/micronumpy/test/test_complex.py b/pypy/module/micronumpy/test/test_complex.py
--- a/pypy/module/micronumpy/test/test_complex.py
+++ b/pypy/module/micronumpy/test/test_complex.py
@@ -139,7 +139,6 @@
def test_fmax(self):
from _numpypy import fmax, array
- import math
nnan, nan, inf, ninf = float('-nan'), float('nan'), float('inf'), float('-inf')
a = array((complex(ninf, 10), complex(10, ninf),
complex( inf, 10), complex(10, inf),
@@ -167,7 +166,6 @@
def test_fmin(self):
from _numpypy import fmin, array
- import math
nnan, nan, inf, ninf = float('-nan'), float('nan'), float('inf'), float('-inf')
a = array((complex(ninf, 10), complex(10, ninf),
complex( inf, 10), complex(10, inf),
@@ -198,7 +196,7 @@
raises(TypeError, signbit, complex(1,1))
def test_reciprocal(self):
- from _numpypy import array, reciprocal, complex64, complex128
+ from _numpypy import array, reciprocal, complex64, complex128, clongdouble
inf = float('inf')
nan = float('nan')
@@ -214,7 +212,7 @@
complex(-r, i),
-0j, 0j, cnan,
cnan, cnan, cnan]
- for c, rel_err in ((complex64, 2e-7), (complex128, 2e-15), ):
+ for c, rel_err in ((complex64, 2e-7), (complex128, 2e-15), (clongdouble, 2e-15)):
actual = reciprocal(array([orig], dtype=c))
for b, a, e in zip(orig, actual, expected):
assert (a[0].real - e.real) < rel_err
@@ -234,13 +232,12 @@
raises(TypeError, copysign, a, b)
def test_exp2(self):
- import math
- from _numpypy import array, exp2, complex128, complex64
+ from _numpypy import array, exp2, complex128, complex64, clongfloat
inf = float('inf')
ninf = -float('inf')
nan = float('nan')
cmpl = complex
- for c,rel_err in ((complex128, 2e-15), (complex64, 1e-7)):
+ for c,rel_err in ((complex128, 2e-15), (complex64, 1e-7), (clongfloat, 2e-15)):
a = [cmpl(-5., 0), cmpl(-5., -5.), cmpl(-5., 5.),
cmpl(0., -5.), cmpl(0., 0.), cmpl(0., 5.),
cmpl(-0., -5.), cmpl(-0., 0.), cmpl(-0., 5.),
@@ -499,7 +496,7 @@
def test_basic(self):
from _numpypy import (complex128, complex64, add, array, dtype,
subtract as sub, multiply, divide, negative, abs, floor_divide,
- real, imag, sign)
+ real, imag, sign, clongfloat)
from _numpypy import (equal, not_equal, greater, greater_equal, less,
less_equal, isnan)
assert real(4.0) == 4.0
@@ -507,7 +504,7 @@
a = array([complex(3.0, 4.0)])
b = a.real
assert b.dtype == dtype(float)
- for complex_ in complex64, complex128:
+ for complex_ in complex64, complex128, clongfloat:
O = complex(0, 0)
c0 = complex_(complex(2.5, 0))
diff --git a/pypy/module/micronumpy/test/test_dtypes.py b/pypy/module/micronumpy/test/test_dtypes.py
--- a/pypy/module/micronumpy/test/test_dtypes.py
+++ b/pypy/module/micronumpy/test/test_dtypes.py
@@ -116,8 +116,11 @@
def test_bool_binop_types(self):
from _numpypy import array, dtype
types = [
- '?', 'b', 'B', 'h', 'H', 'i', 'I', 'l', 'L', 'q', 'Q', 'f', 'd', 'e',
+ '?', 'b', 'B', 'h', 'H', 'i', 'I', 'l', 'L', 'q', 'Q', 'f', 'd',
+ 'e'
]
+ if array([0], dtype='longdouble').itemsize > 8:
+ types += ['g', 'G']
a = array([True], '?')
for t in types:
assert (a + array([0], t)).dtype is dtype(t)
@@ -233,6 +236,7 @@
(numpy.float16, 10.),
(numpy.float32, 2.0),
(numpy.float64, 4.32),
+ (numpy.longdouble, 4.32),
]:
assert hash(tp(value)) == hash(value)
@@ -469,6 +473,19 @@
assert numpy.float64('23.4') == numpy.float64(23.4)
raises(ValueError, numpy.float64, '23.2df')
+ def test_longfloat(self):
+ import _numpypy as numpy
+ # it can be float96 or float128
+ if numpy.longfloat != numpy.float64:
+ assert numpy.longfloat.mro()[1:] == [numpy.floating,
+ numpy.inexact, numpy.number,
+ numpy.generic, object]
+ a = numpy.array([1, 2, 3], numpy.longdouble)
+ assert repr(type(a[1])) == repr(numpy.longdouble)
+ assert numpy.float64(12) == numpy.longdouble(12)
+ assert numpy.float64(12) == numpy.longfloat(12)
+ raises(ValueError, numpy.longfloat, '23.2df')
+
def test_complex_floating(self):
import _numpypy as numpy
@@ -526,6 +543,12 @@
assert numpy.dtype(complex).type is numpy.complex128
assert numpy.dtype("complex").type is numpy.complex128
+ d = numpy.dtype('complex64')
+ assert d.kind == 'c'
+ assert d.num == 14
+ assert d.char == 'F'
+
+
def test_subclass_type(self):
import _numpypy as numpy
diff --git a/pypy/module/micronumpy/test/test_numarray.py b/pypy/module/micronumpy/test/test_numarray.py
--- a/pypy/module/micronumpy/test/test_numarray.py
+++ b/pypy/module/micronumpy/test/test_numarray.py
@@ -2110,7 +2110,7 @@
def test_fromstring_types(self):
from _numpypy import (fromstring, int8, int16, int32, int64, uint8,
- uint16, uint32, float16, float32, float64)
+ uint16, uint32, float16, float32, float64, longfloat, array)
a = fromstring('\xFF', dtype=int8)
assert a[0] == -1
b = fromstring('\xFF', dtype=uint8)
@@ -2133,9 +2133,21 @@
assert j[0] == 12
k = fromstring(self.float16val, dtype=float16)
assert k[0] == float16(5.)
+ dt = array([5],dtype=longfloat).dtype
+ if dt.itemsize == 12:
+ from _numpypy import float96
+ m = fromstring('\x00\x00\x00\x00\x00\x00\x00\xa0\x01@\x00\x00', dtype=float96)
+ elif dt.itemsize==16:
+ from _numpypy import float128
+ m = fromstring('\x00\x00\x00\x00\x00\x00\x00\xa0\x01@\x00\x00\x00\x00\x00\x00', dtype=float128)
+ elif dt.itemsize == 8:
+ skip('longfloat is float64')
+ else:
+ skip('unknown itemsize for longfloat')
+ assert m[0] == longfloat(5.)
def test_fromstring_invalid(self):
- from _numpypy import fromstring, uint16, uint8, int32
+ from _numpypy import fromstring, uint16, uint8
#default dtype is 64-bit float, so 3 bytes should fail
raises(ValueError, fromstring, "\x01\x02\x03")
#3 bytes is not modulo 2 bytes (int16)
diff --git a/pypy/module/micronumpy/types.py b/pypy/module/micronumpy/types.py
--- a/pypy/module/micronumpy/types.py
+++ b/pypy/module/micronumpy/types.py
@@ -14,7 +14,8 @@
from pypy.rpython.lltypesystem import lltype, rffi
from pypy.rlib.rstruct.runpack import runpack
from pypy.rlib.rstruct.nativefmttable import native_is_bigendian
-from pypy.rlib.rstruct.ieee import float_pack, float_unpack, unpack_float
+from pypy.rlib.rstruct.ieee import (float_pack, float_unpack,
+ unpack_float, unpack_float128)
from pypy.tool.sourcetools import func_with_new_name
from pypy.rlib import jit
from pypy.rlib.rstring import StringBuilder
@@ -1496,7 +1497,6 @@
ComponentBoxType = interp_boxes.W_Float32Box
-
NonNativeComplex64 = Complex64
class Complex128(ComplexFloating, BaseType):
@@ -1510,6 +1510,60 @@
NonNativeComplex128 = Complex128
+if interp_boxes.long_double_size == 12:
+ class Float96(BaseType, Float):
+ _attrs_ = ()
+
+ T = rffi.LONGDOUBLE
+ BoxType = interp_boxes.W_Float96Box
+ format_code = "q"
+
+ def runpack_str(self, s):
+ assert len(s) == 12
+ fval = unpack_float128(s, native_is_bigendian)
+ return self.box(fval)
+
+ class NonNativeFloat96(Float96):
+ pass
+
+ class Complex192(ComplexFloating, BaseType):
+ _attrs_ = ()
+
+ T = rffi.CHAR
+ _COMPONENTS_T = rffi.LONGDOUBLE
+ BoxType = interp_boxes.W_Complex192Box
+ ComponentBoxType = interp_boxes.W_Float96Box
+
+ NonNativeComplex192 = Complex192
+
+
+elif interp_boxes.long_double_size == 16:
+ class Float128(BaseType, Float):
+ _attrs_ = ()
+
+ T = rffi.LONGDOUBLE
+ BoxType = interp_boxes.W_Float128Box
+ format_code = "q"
+
+ def runpack_str(self, s):
+ assert len(s) == 16
+ fval = unpack_float128(s, native_is_bigendian)
+ return self.box(fval)
+
+ class NonNativeFloat128(Float128):
+ pass
+
+ class Complex256(ComplexFloating, BaseType):
+ _attrs_ = ()
+
+ T = rffi.CHAR
+ _COMPONENTS_T = rffi.LONGDOUBLE
+ BoxType = interp_boxes.W_Complex256Box
+ ComponentBoxType = interp_boxes.W_Float128Box
+
+
+ NonNativeComplex256 = Complex256
+
class BaseStringType(object):
_mixin_ = True
diff --git a/pypy/rlib/objectmodel.py b/pypy/rlib/objectmodel.py
--- a/pypy/rlib/objectmodel.py
+++ b/pypy/rlib/objectmodel.py
@@ -299,6 +299,10 @@
hop.exception_cannot_occur()
return hop.inputconst(lltype.Bool, hop.s_result.const)
+def int_to_bytearray(i):
+ # XXX this can be made more efficient in the future
+ return bytearray(str(i))
+
# ____________________________________________________________
class FREED_OBJECT(object):
diff --git a/pypy/rlib/parsing/ebnfparse.py b/pypy/rlib/parsing/ebnfparse.py
--- a/pypy/rlib/parsing/ebnfparse.py
+++ b/pypy/rlib/parsing/ebnfparse.py
@@ -246,9 +246,10 @@
real_expansions.append(expansion)
real_changes.append(change)
continue
- assert n != len(expansion), (
- "currently an expansion needs at least one"
- "symbol that always has to occur")
+ if n == len(expansion):
+ raise ValueError("Rule %r's expansion needs "
+ "at least one symbol with >0 repetitions"
+ % rule.nonterminal)
slices = []
start = 0
for i, (maybe, symbol) in enumerate(
diff --git a/pypy/rlib/parsing/test/test_ebnfparse.py b/pypy/rlib/parsing/test/test_ebnfparse.py
--- a/pypy/rlib/parsing/test/test_ebnfparse.py
+++ b/pypy/rlib/parsing/test/test_ebnfparse.py
@@ -318,7 +318,7 @@
""")
excinfo = py.test.raises(ValueError, make_parse_function, regexs, rules)
assert "primari" in str(excinfo.value)
-
+
def test_starred_star():
regexs, rules, ToAST = parse_ebnf("""
IGNORE: " ";
@@ -470,3 +470,11 @@
t = ToAST().transform(t)
assert len(t.children) == 6
excinfo = py.test.raises(ParseError, parse, "a")
+
+def test_zero_repetition_production():
+ grammar = """
+IGNORE: " ";
+foo: "A"?;
+"""
+ excinfo = py.test.raises(ValueError, parse_ebnf, grammar)
+ assert "foo" in str(excinfo.value)
diff --git a/pypy/rlib/rmmap.py b/pypy/rlib/rmmap.py
--- a/pypy/rlib/rmmap.py
+++ b/pypy/rlib/rmmap.py
@@ -119,8 +119,9 @@
PTR = rffi.CCHARP
if _CYGWIN:
- c_malloc, _ = external('malloc', [size_t], PTR)
- c_free, _ = external('free', [PTR], lltype.Void)
+ # XXX: macro=True hack for newer versions of Cygwin (as of 12/2012)
+ c_malloc, _ = external('malloc', [size_t], PTR, macro=True)
+ c_free, _ = external('free', [PTR], lltype.Void, macro=True)
c_memmove, _ = external('memmove', [PTR, PTR, size_t], lltype.Void)
diff --git a/pypy/rlib/rstruct/ieee.py b/pypy/rlib/rstruct/ieee.py
--- a/pypy/rlib/rstruct/ieee.py
+++ b/pypy/rlib/rstruct/ieee.py
@@ -25,11 +25,90 @@
int_part += 1
return int_part
+def float_unpack80(QQ):
+ '''Unpack a (mant, exp) tuple of r_ulonglong in 80-bit extended format
+ into a long double float
+ '''
+ MIN_EXP = -16381
+ MAX_EXP = 16384
+ MANT_DIG = 64
+ TOPBITS = 80 - 64
+ one = r_ulonglong(1)
+ if len(QQ) != 2:
+ raise ValueError("QQ must be two 64 bit uints")
+ if not objectmodel.we_are_translated():
+ # This tests generates wrong code when translated:
+ # with gcc, shifting a 64bit int by 64 bits does
+ # not change the value.
+ if QQ[1] >> TOPBITS:
+ raise ValueError("input '%r' out of range '%r'" % (QQ, QQ[1]>>TOPBITS))
+
+ # extract pieces with explicit one in MANT_DIG
+ sign = rarithmetic.intmask(QQ[1] >> TOPBITS - 1)
+ exp = rarithmetic.intmask((QQ[1] & ((one << TOPBITS - 1) - 1)))
+ mant = QQ[0]
+
+ if exp == MAX_EXP - MIN_EXP + 2:
+ # nan or infinity
+ result = rfloat.NAN if mant &((one << MANT_DIG - 1) - 1) else rfloat.INFINITY
+ else:
+ # normal
+ result = math.ldexp(mant, exp + MIN_EXP - MANT_DIG - 1)
+ return -result if sign else result
+
def float_unpack(Q, size):
- """Convert a 16-bit, 32-bit or 64-bit integer created
+ """Convert a 16-bit, 32-bit 64-bit integer created
by float_pack into a Python float."""
+ if size == 8:
+ MIN_EXP = -1021 # = sys.float_info.min_exp
+ MAX_EXP = 1024 # = sys.float_info.max_exp
+ MANT_DIG = 53 # = sys.float_info.mant_dig
+ BITS = 64
+ one = r_ulonglong(1)
+ elif size == 4:
+ MIN_EXP = -125 # C's FLT_MIN_EXP
+ MAX_EXP = 128 # FLT_MAX_EXP
+ MANT_DIG = 24 # FLT_MANT_DIG
+ BITS = 32
+ one = r_ulonglong(1)
+ elif size == 2:
+ MIN_EXP = -13
+ MAX_EXP = 16
+ MANT_DIG = 11
+ BITS = 16
+ one = r_ulonglong(1)
+ else:
+ raise ValueError("invalid size value")
+ if not objectmodel.we_are_translated():
+ # This tests generates wrong code when translated:
+ # with gcc, shifting a 64bit int by 64 bits does
+ # not change the value.
+ if Q >> BITS:
+ raise ValueError("input '%r' out of range '%r'" % (Q, Q>>BITS))
+
+ # extract pieces with assumed 1.mant values
+ sign = rarithmetic.intmask(Q >> BITS - 1)
+ exp = rarithmetic.intmask((Q & ((one << BITS - 1) - (one << MANT_DIG - 1))) >> MANT_DIG - 1)
+ mant = Q & ((one << MANT_DIG - 1) - 1)
+
+ if exp == MAX_EXP - MIN_EXP + 2:
+ # nan or infinity
+ result = rfloat.NAN if mant else rfloat.INFINITY
+ elif exp == 0:
+ # subnormal or zero
+ result = math.ldexp(mant, MIN_EXP - MANT_DIG)
+ else:
+ # normal: add implicit one value
+ mant += one << MANT_DIG - 1
+ result = math.ldexp(mant, exp + MIN_EXP - MANT_DIG - 1)
+ return -result if sign else result
+
+
+def float_pack(x, size):
+ """Convert a Python float x into a 64-bit unsigned integer
+ with the same byte representation."""
if size == 8:
MIN_EXP = -1021 # = sys.float_info.min_exp
MAX_EXP = 1024 # = sys.float_info.max_exp
@@ -45,54 +124,13 @@
MAX_EXP = 16
MANT_DIG = 11
BITS = 16
- else:
- raise ValueError("invalid size value")
-
- if not objectmodel.we_are_translated():
- # This tests generates wrong code when translated:
- # with gcc, shifting a 64bit int by 64 bits does
- # not change the value.
- if Q >> BITS:
- raise ValueError("input out of range")
-
- # extract pieces
- one = r_ulonglong(1)
- sign = rarithmetic.intmask(Q >> BITS - 1)
- exp = rarithmetic.intmask((Q & ((one << BITS - 1) - (one << MANT_DIG - 1))) >> MANT_DIG - 1)
- mant = Q & ((one << MANT_DIG - 1) - 1)
-
- if exp == MAX_EXP - MIN_EXP + 2:
- # nan or infinity
- result = rfloat.NAN if mant else rfloat.INFINITY
- elif exp == 0:
- # subnormal or zero
- result = math.ldexp(mant, MIN_EXP - MANT_DIG)
- else:
- # normal
- mant += one << MANT_DIG - 1
- result = math.ldexp(mant, exp + MIN_EXP - MANT_DIG - 1)
- return -result if sign else result
-
-
-def float_pack(x, size):
- """Convert a Python float x into a 64-bit unsigned integer
- with the same byte representation."""
-
- if size == 8:
- MIN_EXP = -1021 # = sys.float_info.min_exp
- MAX_EXP = 1024 # = sys.float_info.max_exp
- MANT_DIG = 53 # = sys.float_info.mant_dig
- BITS = 64
- elif size == 4:
- MIN_EXP = -125 # C's FLT_MIN_EXP
- MAX_EXP = 128 # FLT_MAX_EXP
- MANT_DIG = 24 # FLT_MANT_DIG
- BITS = 32
- elif size == 2:
- MIN_EXP = -13
- MAX_EXP = 16
- MANT_DIG = 11
- BITS = 16
+ elif size == 16 or size == 12:
+ #Implement a x86-hardware extended 80 bit format
+ # with explicit 1 in bit 64
+ MIN_EXP = -16381
+ MAX_EXP = 16384
+ MANT_DIG = 64
+ BITS = 80
else:
raise ValueError("invalid size value")
@@ -139,26 +177,97 @@
assert 0 <= mant < 1 << MANT_DIG - 1
assert 0 <= exp <= MAX_EXP - MIN_EXP + 2
assert 0 <= sign <= 1
-
+ if size==12 or size == 16:
+ mant |= r_ulonglong(1) <<(MANT_DIG-1) #1 is explicit for 80bit extended format
+ exp = exp << 1
exp = r_ulonglong(exp)
sign = r_ulonglong(sign)
return ((sign << BITS - 1) | (exp << MANT_DIG - 1)) | mant
+def float_pack80(x):
+ """Convert a Python float x into two 64-bit unsigned integers
+ with 80 bit extended representation."""
+ MIN_EXP = -16381
+ MAX_EXP = 16384
+ MANT_DIG = 64
+ BITS = 80
+
+ sign = rfloat.copysign(1.0, x) < 0.0
+ if not rfloat.isfinite(x):
+ if rfloat.isinf(x):
+ mant = r_ulonglong(0)
+ exp = MAX_EXP - MIN_EXP + 2
+ else: # rfloat.isnan(x):
+ mant = (r_ulonglong(1) << (MANT_DIG-2)) - 1 # other values possible
+ exp = MAX_EXP - MIN_EXP + 2
+ elif x == 0.0:
+ mant = r_ulonglong(0)
+ exp = 0
+ else:
+ m, e = math.frexp(abs(x)) # abs(x) == m * 2**e
+ exp = e - (MIN_EXP - 1)
+ if exp > 0:
+ # Normal case. Avoid uint64 overflow by using MANT_DIG-1
+ mant = round_to_nearest(m * (r_ulonglong(1) << MANT_DIG - 1))
+ else:
+ # Subnormal case.
+ if exp + MANT_DIG - 1 >= 0:
+ mant = round_to_nearest(m * (r_ulonglong(1) << exp + MANT_DIG - 1))
+ else:
+ mant = r_ulonglong(0)
+ exp = 0
+
+ # Special case: rounding produced a MANT_DIG-bit mantissa.
+ if mant == r_ulonglong(1) << MANT_DIG - 1:
+ mant = r_ulonglong(0)
+ exp += 1
+
+ # Raise on overflow (in some circumstances, may want to return
+ # infinity instead).
+ if exp >= MAX_EXP - MIN_EXP + 2:
+ raise OverflowError("float too large to pack in this format")
+
+ # check constraints
+ if not objectmodel.we_are_translated():
+ assert 0 <= mant < 1 << MANT_DIG - 1
+ assert 0 <= exp <= MAX_EXP - MIN_EXP + 2
+ assert 0 <= sign <= 1
+ mant = mant << 1
+ exp = r_ulonglong(exp)
+ sign = r_ulonglong(sign)
+ return (mant, (sign << BITS - MANT_DIG - 1) | exp)
+
@jit.unroll_safe
def pack_float(result, x, size, be):
l = []
- unsigned = float_pack(x, size)
- for i in range(size):
- l.append(chr((unsigned >> (i * 8)) & 0xFF))
+ if size == 12 or size == 16:
+ unsigned = float_pack80(x)
+ for i in range(8):
+ l.append(chr((unsigned[0] >> (i * 8)) & 0xFF))
+ for i in range(size - 8):
+ l.append(chr((unsigned[1] >> (i * 8)) & 0xFF))
+ else:
+ unsigned = float_pack(x, size)
+ for i in range(size):
+ l.append(chr((unsigned >> (i * 8)) & 0xFF))
if be:
l.reverse()
result.append("".join(l))
-
def unpack_float(s, be):
unsigned = r_ulonglong(0)
for i in range(len(s)):
c = ord(s[len(s) - 1 - i if be else i])
unsigned |= r_ulonglong(c) << (i * 8)
return float_unpack(unsigned, len(s))
+
+def unpack_float128(s, be):
+ QQ = [r_ulonglong(0), r_ulonglong(0)]
+ for i in range(8):
+ c = ord(s[len(s) - 1 - i if be else i])
+ QQ[0] |= r_ulonglong(c) << (i * 8)
+ for i in range(8, len(s)):
+ c = ord(s[len(s) - 1 - i if be else i])
+ QQ[1] |= r_ulonglong(c) << ((i - 8) * 8)
+ return float_unpack80(QQ)
diff --git a/pypy/rlib/rstruct/test/test_ieee.py b/pypy/rlib/rstruct/test/test_ieee.py
--- a/pypy/rlib/rstruct/test/test_ieee.py
+++ b/pypy/rlib/rstruct/test/test_ieee.py
@@ -3,7 +3,7 @@
import struct
from pypy.rlib.rfloat import isnan
-from pypy.rlib.rstruct.ieee import float_pack, float_unpack
+from pypy.rlib.rstruct.ieee import float_pack, float_unpack, float_pack80, float_unpack80
class TestFloatPacking:
@@ -18,6 +18,10 @@
y = float_unpack(Q, 8)
assert repr(x) == repr(y)
+ Q = float_pack80(x)
+ y = float_unpack80(Q)
+ assert repr(x) == repr(y),'%r != %r, Q=%r'%(x, y, Q)
+
# check that packing agrees with the struct module
struct_pack8 = struct.unpack('<Q', struct.pack('<d', x))[0]
float_pack8 = float_pack(x, 8)
@@ -34,10 +38,20 @@
float_pack4 = "overflow"
assert struct_pack4 == float_pack4
+ if float_pack4 == "overflow":
+ return
+
# if we didn't overflow, try round-tripping the binary32 value
- if float_pack4 != "overflow":
- roundtrip = float_pack(float_unpack(float_pack4, 4), 4)
- assert float_pack4 == roundtrip
+ roundtrip = float_pack(float_unpack(float_pack4, 4), 4)
+ assert float_pack4 == roundtrip
+
+ try:
+ float_pack2 = float_pack(x, 2)
+ except OverflowError:
+ return
+
+ roundtrip = float_pack(float_unpack(float_pack2, 2), 2)
+ assert (float_pack2,x) == (roundtrip,x)
def test_infinities(self):
self.check_float(float('inf'))
@@ -48,12 +62,18 @@
self.check_float(-0.0)
def test_nans(self):
+ Q = float_pack80(float('nan'))
+ y = float_unpack80(Q)
+ assert repr(y) == 'nan'
Q = float_pack(float('nan'), 8)
y = float_unpack(Q, 8)
assert repr(y) == 'nan'
L = float_pack(float('nan'), 4)
z = float_unpack(L, 4)
assert repr(z) == 'nan'
+ L = float_pack(float('nan'), 2)
+ z = float_unpack(L, 2)
+ assert repr(z) == 'nan'
def test_simple(self):
test_values = [1e-10, 0.00123, 0.5, 0.7, 1.0, 123.456, 1e10]
diff --git a/pypy/rpython/lltypesystem/lltype.py b/pypy/rpython/lltypesystem/lltype.py
--- a/pypy/rpython/lltypesystem/lltype.py
+++ b/pypy/rpython/lltypesystem/lltype.py
@@ -1456,7 +1456,7 @@
return _ptr(Ptr(self._TYPE), self, True)
def _as_obj(self, check=True):
return self
- def _normalizedcontainer(self):
+ def _normalizedcontainer(self, check=True):
return self
def _getid(self):
return id(self)
More information about the pypy-commit
mailing list