[pypy-commit] pypy arm-backend-2: merge default
bivab
noreply at buildbot.pypy.org
Mon Nov 21 17:13:34 CET 2011
Author: David Schneider <david.schneider at picle.org>
Branch: arm-backend-2
Changeset: r49626:32cc8083b6f1
Date: 2011-11-21 14:18 +0100
http://bitbucket.org/pypy/pypy/changeset/32cc8083b6f1/
Log: merge default
diff --git a/pypy/doc/release-1.7.0.rst b/pypy/doc/release-1.7.0.rst
new file mode 100644
--- /dev/null
+++ b/pypy/doc/release-1.7.0.rst
@@ -0,0 +1,94 @@
+==================================
+PyPy 1.7 - widening the sweet spot
+==================================
+
+We're pleased to announce the 1.7 release of PyPy. As became a habit, this
+release brings a lot of bugfixes and performance improvements over the 1.6
+release. However, unlike the previous releases, the focus has been on widening
+the "sweet spot" of PyPy. That is, classes of Python code that PyPy can greatly
+speed up should be vastly improved with this release. You can download the 1.7
+release here:
+
+ http://pypy.org/download.html
+
+What is PyPy?
+=============
+
+PyPy is a very compliant Python interpreter, almost a drop-in replacement for
+CPython 2.7. It's fast (`pypy 1.7 and cpython 2.7.1`_ performance comparison)
+due to its integrated tracing JIT compiler.
+
+This release supports x86 machines running Linux 32/64, Mac OS X 32/64 or
+Windows 32. Windows 64 work is ongoing, but not yet natively supported.
+
+The main topic of this release is widening the range of code which PyPy
+can greatly speed up. On average on
+our benchmark suite, PyPy 1.7 is around **30%** faster than PyPy 1.6 and up
+to **20 times** faster on some benchmarks.
+
+.. _`pypy 1.7 and cpython 2.7.1`: http://speed.pypy.org
+
+
+Highlights
+==========
+
+* Numerous performance improvements. There are too many examples which python
+ constructs now should behave faster to list them.
+
+* Bugfixes and compatibility fixes with CPython.
+
+* Windows fixes.
+
+* PyPy now comes with stackless features enabled by default. However,
+ any loop using stackless features will interrupt the JIT for now, so no real
+ performance improvement for stackless-based programs. Contact pypy-dev for
+ info how to help on removing this restriction.
+
+* NumPy effort in PyPy was renamed numpypy. In order to try using it, simply
+ write::
+
+ import numpypy as numpy
+
+ at the beginning of your program. There is a huge progress on numpy in PyPy
+ since 1.6, the main feature being implementation of dtypes.
+
+* JSON encoder (but not decoder) has been replaced with a new one. This one
+ is written in pure Python, but is known to outperform CPython's C extension
+ up to **2 times** in some cases. It's about **20 times** faster than
+ the one that we had in 1.6.
+
+* The memory footprint of some of our RPython modules has been drastically
+ improved. This should impact any applications using for example cryptography,
+ like tornado.
+
+* There was some progress in exposing even more CPython C API via cpyext.
+
+Things that didn't make it, expect in 1.8 soon
+==============================================
+
+There is an ongoing work, which while didn't make it to the release, is
+probably worth mentioning here. This is what you should probably expect in
+1.8 some time soon:
+
+* Specialized list implementation. There is a branch that implements lists of
+ integers/floats/strings as compactly as array.array. This should drastically
+ improve performance/memory impact of some applications
+
+* NumPy effort is progressing forward, with multi-dimensional arrays coming
+ soon.
+
+* There are two brand new JIT assembler backends, notably for the PowerPC and
+ ARM processors.
+
+Fundraising
+===========
+
+It's maybe worth mentioning that we're running fundraising campaigns for
+NumPy effort in PyPy and for Python 3 in PyPy. In case you want to see any
+of those happen faster, we urge you to donate to `numpy proposal`_ or
+`py3k proposal`_. In case you want PyPy to progress, but you trust us with
+the general direction, you can always donate to the `general pot`_.
+
+.. _`numpy proposal`: http://pypy.org/numpydonate.html
+.. _`py3k proposal`: http://pypy.org/py3donate.html
+.. _`general pot`: http://pypy.org
diff --git a/pypy/jit/backend/llgraph/llimpl.py b/pypy/jit/backend/llgraph/llimpl.py
--- a/pypy/jit/backend/llgraph/llimpl.py
+++ b/pypy/jit/backend/llgraph/llimpl.py
@@ -20,7 +20,6 @@
from pypy.jit.backend.llgraph import symbolic
from pypy.jit.codewriter import longlong
-from pypy.rlib import libffi
from pypy.rlib.objectmodel import ComputedIntSymbolic, we_are_translated
from pypy.rlib.rarithmetic import ovfcheck
from pypy.rlib.rarithmetic import r_longlong, r_ulonglong, r_uint
@@ -326,12 +325,12 @@
loop = _from_opaque(loop)
loop.operations.append(Operation(opnum))
-def compile_add_descr(loop, ofs, type, arg_types, extrainfo, width):
+def compile_add_descr(loop, ofs, type, arg_types):
from pypy.jit.backend.llgraph.runner import Descr
loop = _from_opaque(loop)
op = loop.operations[-1]
assert isinstance(type, str) and len(type) == 1
- op.descr = Descr(ofs, type, arg_types=arg_types, extrainfo=extrainfo, width=width)
+ op.descr = Descr(ofs, type, arg_types=arg_types)
def compile_add_descr_arg(loop, ofs, type, arg_types):
from pypy.jit.backend.llgraph.runner import Descr
@@ -826,16 +825,6 @@
else:
raise NotImplementedError
- def op_getinteriorfield_raw(self, descr, array, index):
- if descr.typeinfo == REF:
- return do_getinteriorfield_raw_ptr(array, index, descr.width, descr.ofs)
- elif descr.typeinfo == INT:
- return do_getinteriorfield_raw_int(array, index, descr.width, descr.ofs)
- elif descr.typeinfo == FLOAT:
- return do_getinteriorfield_raw_float(array, index, descr.width, descr.ofs)
- else:
- raise NotImplementedError
-
def op_setinteriorfield_gc(self, descr, array, index, newvalue):
if descr.typeinfo == REF:
return do_setinteriorfield_gc_ptr(array, index, descr.ofs,
@@ -849,16 +838,6 @@
else:
raise NotImplementedError
- def op_setinteriorfield_raw(self, descr, array, index, newvalue):
- if descr.typeinfo == REF:
- return do_setinteriorfield_raw_ptr(array, index, newvalue, descr.width, descr.ofs)
- elif descr.typeinfo == INT:
- return do_setinteriorfield_raw_int(array, index, newvalue, descr.width, descr.ofs)
- elif descr.typeinfo == FLOAT:
- return do_setinteriorfield_raw_float(array, index, newvalue, descr.width, descr.ofs)
- else:
- raise NotImplementedError
-
def op_setfield_gc(self, fielddescr, struct, newvalue):
if fielddescr.typeinfo == REF:
do_setfield_gc_ptr(struct, fielddescr.ofs, newvalue)
@@ -1424,14 +1403,6 @@
struct = array._obj.container.getitem(index)
return cast_to_ptr(_getinteriorfield_gc(struct, fieldnum))
-def _getinteriorfield_raw(ffitype, array, index, width, ofs):
- addr = rffi.cast(rffi.VOIDP, array)
- return libffi.array_getitem(ffitype, width, addr, index, ofs)
-
-def do_getinteriorfield_raw_int(array, index, width, ofs):
- res = _getinteriorfield_raw(libffi.types.slong, array, index, width, ofs)
- return res
-
def _getfield_raw(struct, fieldnum):
STRUCT, fieldname = symbolic.TokenToField[fieldnum]
ptr = cast_from_int(lltype.Ptr(STRUCT), struct)
@@ -1508,14 +1479,7 @@
return do_setinteriorfield_gc
do_setinteriorfield_gc_int = new_setinteriorfield_gc(cast_from_int)
do_setinteriorfield_gc_float = new_setinteriorfield_gc(cast_from_floatstorage)
-do_setinteriorfield_gc_ptr = new_setinteriorfield_gc(cast_from_ptr)
-
-def new_setinteriorfield_raw(ffitype):
- def do_setinteriorfield_raw(array, index, newvalue, width, ofs):
- addr = rffi.cast(rffi.VOIDP, array)
- return libffi.array_setitem(ffitype, width, addr, index, ofs, newvalue)
- return do_setinteriorfield_raw
-do_setinteriorfield_raw_int = new_setinteriorfield_raw(libffi.types.slong)
+do_setinteriorfield_gc_ptr = new_setinteriorfield_gc(cast_from_ptr)
def do_setfield_raw_int(struct, fieldnum, newvalue):
STRUCT, fieldname = symbolic.TokenToField[fieldnum]
diff --git a/pypy/jit/backend/llgraph/runner.py b/pypy/jit/backend/llgraph/runner.py
--- a/pypy/jit/backend/llgraph/runner.py
+++ b/pypy/jit/backend/llgraph/runner.py
@@ -23,10 +23,8 @@
class Descr(history.AbstractDescr):
def __init__(self, ofs, typeinfo, extrainfo=None, name=None,
- arg_types=None, count_fields_if_immut=-1, ffi_flags=0, width=-1):
-
+ arg_types=None, count_fields_if_immut=-1, ffi_flags=0):
self.ofs = ofs
- self.width = width
self.typeinfo = typeinfo
self.extrainfo = extrainfo
self.name = name
@@ -121,14 +119,14 @@
return False
def getdescr(self, ofs, typeinfo='?', extrainfo=None, name=None,
- arg_types=None, count_fields_if_immut=-1, ffi_flags=0, width=-1):
+ arg_types=None, count_fields_if_immut=-1, ffi_flags=0):
key = (ofs, typeinfo, extrainfo, name, arg_types,
- count_fields_if_immut, ffi_flags, width)
+ count_fields_if_immut, ffi_flags)
try:
return self._descrs[key]
except KeyError:
descr = Descr(ofs, typeinfo, extrainfo, name, arg_types,
- count_fields_if_immut, ffi_flags, width)
+ count_fields_if_immut, ffi_flags)
self._descrs[key] = descr
return descr
@@ -181,8 +179,7 @@
descr = op.getdescr()
if isinstance(descr, Descr):
llimpl.compile_add_descr(c, descr.ofs, descr.typeinfo,
- descr.arg_types, descr.extrainfo,
- descr.width)
+ descr.arg_types)
if (isinstance(descr, history.LoopToken) and
op.getopnum() != rop.JUMP):
llimpl.compile_add_loop_token(c, descr)
@@ -327,22 +324,10 @@
def interiorfielddescrof(self, A, fieldname):
S = A.OF
- width = symbolic.get_size(A)
+ ofs2 = symbolic.get_size(A)
ofs, size = symbolic.get_field_token(S, fieldname)
token = history.getkind(getattr(S, fieldname))
- return self.getdescr(ofs, token[0], name=fieldname, width=width)
-
- def interiorfielddescrof_dynamic(self, offset, width, fieldsize,
- is_pointer, is_float, is_signed):
-
- if is_pointer:
- typeinfo = REF
- elif is_float:
- typeinfo = FLOAT
- else:
- typeinfo = INT
- # we abuse the arg_types field to distinguish dynamic and static descrs
- return Descr(offset, typeinfo, arg_types='dynamic', name='<dynamic interior field>', width=width)
+ return self.getdescr(ofs, token[0], name=fieldname, extrainfo=ofs2)
def calldescrof(self, FUNC, ARGS, RESULT, extrainfo):
arg_types = []
diff --git a/pypy/jit/backend/llsupport/descr.py b/pypy/jit/backend/llsupport/descr.py
--- a/pypy/jit/backend/llsupport/descr.py
+++ b/pypy/jit/backend/llsupport/descr.py
@@ -111,16 +111,6 @@
def repr_of_descr(self):
return '<%s %s %s>' % (self._clsname, self.name, self.offset)
-class DynamicFieldDescr(BaseFieldDescr):
- def __init__(self, offset, fieldsize, is_pointer, is_float, is_signed):
- self.offset = offset
- self._fieldsize = fieldsize
- self._is_pointer_field = is_pointer
- self._is_float_field = is_float
- self._is_field_signed = is_signed
-
- def get_field_size(self, translate_support_code):
- return self._fieldsize
class NonGcPtrFieldDescr(BaseFieldDescr):
_clsname = 'NonGcPtrFieldDescr'
@@ -192,7 +182,6 @@
def repr_of_descr(self):
return '<%s>' % self._clsname
-
class NonGcPtrArrayDescr(BaseArrayDescr):
_clsname = 'NonGcPtrArrayDescr'
def get_item_size(self, translate_support_code):
@@ -222,13 +211,6 @@
def get_ofs_length(self, translate_support_code):
return -1
-class DynamicArrayNoLengthDescr(BaseArrayNoLengthDescr):
- def __init__(self, itemsize):
- self.itemsize = itemsize
-
- def get_item_size(self, translate_support_code):
- return self.itemsize
-
class NonGcPtrArrayNoLengthDescr(BaseArrayNoLengthDescr):
_clsname = 'NonGcPtrArrayNoLengthDescr'
def get_item_size(self, translate_support_code):
diff --git a/pypy/jit/backend/llsupport/llmodel.py b/pypy/jit/backend/llsupport/llmodel.py
--- a/pypy/jit/backend/llsupport/llmodel.py
+++ b/pypy/jit/backend/llsupport/llmodel.py
@@ -9,10 +9,9 @@
from pypy.jit.backend.llsupport import symbolic
from pypy.jit.backend.llsupport.symbolic import WORD, unroll_basic_sizes
from pypy.jit.backend.llsupport.descr import (get_size_descr,
- get_field_descr, BaseFieldDescr, DynamicFieldDescr, get_array_descr,
- BaseArrayDescr, DynamicArrayNoLengthDescr, get_call_descr,
- BaseIntCallDescr, GcPtrCallDescr, FloatCallDescr, VoidCallDescr,
- InteriorFieldDescr, get_interiorfield_descr)
+ get_field_descr, BaseFieldDescr, get_array_descr, BaseArrayDescr,
+ get_call_descr, BaseIntCallDescr, GcPtrCallDescr, FloatCallDescr,
+ VoidCallDescr, InteriorFieldDescr, get_interiorfield_descr)
from pypy.jit.backend.llsupport.asmmemmgr import AsmMemoryManager
@@ -241,12 +240,6 @@
def interiorfielddescrof(self, A, fieldname):
return get_interiorfield_descr(self.gc_ll_descr, A, A.OF, fieldname)
- def interiorfielddescrof_dynamic(self, offset, width, fieldsize,
- is_pointer, is_float, is_signed):
- arraydescr = DynamicArrayNoLengthDescr(width)
- fielddescr = DynamicFieldDescr(offset, fieldsize, is_pointer, is_float, is_signed)
- return InteriorFieldDescr(arraydescr, fielddescr)
-
def unpack_arraydescr(self, arraydescr):
assert isinstance(arraydescr, BaseArrayDescr)
return arraydescr.get_base_size(self.translate_support_code)
diff --git a/pypy/jit/backend/llsupport/test/test_gc.py b/pypy/jit/backend/llsupport/test/test_gc.py
--- a/pypy/jit/backend/llsupport/test/test_gc.py
+++ b/pypy/jit/backend/llsupport/test/test_gc.py
@@ -101,7 +101,7 @@
gcrootmap.put(retaddr, shapeaddr)
assert gcrootmap._gcmap[0] == retaddr
assert gcrootmap._gcmap[1] == shapeaddr
- p = rffi.cast(rffi.LONGP, gcrootmap.gcmapstart())
+ p = rffi.cast(rffi.SIGNEDP, gcrootmap.gcmapstart())
assert p[0] == retaddr
assert (gcrootmap.gcmapend() ==
gcrootmap.gcmapstart() + rffi.sizeof(lltype.Signed) * 2)
diff --git a/pypy/jit/backend/model.py b/pypy/jit/backend/model.py
--- a/pypy/jit/backend/model.py
+++ b/pypy/jit/backend/model.py
@@ -188,35 +188,38 @@
lst[n] = None
self.fail_descr_free_list.extend(faildescr_indices)
- def sizeof(self, S):
+ @staticmethod
+ def sizeof(S):
raise NotImplementedError
- def fielddescrof(self, S, fieldname):
+ @staticmethod
+ def fielddescrof(S, fieldname):
"""Return the Descr corresponding to field 'fieldname' on the
structure 'S'. It is important that this function (at least)
caches the results."""
raise NotImplementedError
- def interiorfielddescrof(self, A, fieldname):
+ @staticmethod
+ def arraydescrof(A):
raise NotImplementedError
- def interiorfielddescrof_dynamic(self, offset, width, fieldsize, is_pointer,
- is_float, is_signed):
- raise NotImplementedError
-
- def arraydescrof(self, A):
- raise NotImplementedError
-
- def calldescrof(self, FUNC, ARGS, RESULT):
+ @staticmethod
+ def calldescrof(FUNC, ARGS, RESULT):
# FUNC is the original function type, but ARGS is a list of types
# with Voids removed
raise NotImplementedError
- def methdescrof(self, SELFTYPE, methname):
+ @staticmethod
+ def methdescrof(SELFTYPE, methname):
# must return a subclass of history.AbstractMethDescr
raise NotImplementedError
- def typedescrof(self, TYPE):
+ @staticmethod
+ def typedescrof(TYPE):
+ raise NotImplementedError
+
+ @staticmethod
+ def interiorfielddescrof(A, fieldname):
raise NotImplementedError
# ---------- the backend-dependent operations ----------
diff --git a/pypy/jit/backend/x86/test/test_zll_random.py b/pypy/jit/backend/test/test_zll_stress.py
rename from pypy/jit/backend/x86/test/test_zll_random.py
rename to pypy/jit/backend/test/test_zll_stress.py
diff --git a/pypy/jit/backend/x86/assembler.py b/pypy/jit/backend/x86/assembler.py
--- a/pypy/jit/backend/x86/assembler.py
+++ b/pypy/jit/backend/x86/assembler.py
@@ -8,8 +8,8 @@
from pypy.rpython.lltypesystem.lloperation import llop
from pypy.rpython.annlowlevel import llhelper
from pypy.jit.backend.model import CompiledLoopToken
-from pypy.jit.backend.x86.regalloc import (RegAlloc, get_ebp_ofs, _get_scale,
- gpr_reg_mgr_cls, _valid_addressing_size)
+from pypy.jit.backend.x86.regalloc import (RegAlloc, get_ebp_ofs,
+ _get_scale, gpr_reg_mgr_cls)
from pypy.jit.backend.x86.arch import (FRAME_FIXED_SIZE, FORCE_INDEX_OFS, WORD,
IS_X86_32, IS_X86_64)
@@ -403,7 +403,7 @@
after()
_NOARG_FUNC = lltype.Ptr(lltype.FuncType([], lltype.Void))
- _CLOSESTACK_FUNC = lltype.Ptr(lltype.FuncType([rffi.LONGP],
+ _CLOSESTACK_FUNC = lltype.Ptr(lltype.FuncType([rffi.SIGNEDP],
lltype.Void))
def _build_release_gil(self, gcrootmap):
@@ -1601,10 +1601,8 @@
assert isinstance(itemsize_loc, ImmedLoc)
if isinstance(index_loc, ImmedLoc):
temp_loc = imm(index_loc.value * itemsize_loc.value)
- elif _valid_addressing_size(itemsize_loc.value):
- return AddressLoc(base_loc, index_loc, _get_scale(itemsize_loc.value), ofs_loc.value)
else:
- # XXX should not use IMUL in more cases, it can use a clever LEA
+ # XXX should not use IMUL in most cases
assert isinstance(temp_loc, RegLoc)
assert isinstance(index_loc, RegLoc)
assert not temp_loc.is_xmm
@@ -1621,8 +1619,6 @@
ofs_loc)
self.load_from_mem(resloc, src_addr, fieldsize_loc, sign_loc)
- genop_getinteriorfield_raw = genop_getinteriorfield_gc
-
def genop_discard_setfield_gc(self, op, arglocs):
base_loc, ofs_loc, size_loc, value_loc = arglocs
@@ -1638,8 +1634,6 @@
ofs_loc)
self.save_into_mem(dest_addr, value_loc, fieldsize_loc)
- genop_discard_setinteriorfield_raw = genop_discard_setinteriorfield_gc
-
def genop_discard_setarrayitem_gc(self, op, arglocs):
base_loc, ofs_loc, value_loc, size_loc, baseofs = arglocs
assert isinstance(baseofs, ImmedLoc)
@@ -1980,10 +1974,10 @@
kind = code & 3
code = (code - self.CODE_FROMSTACK) >> 2
stackloc = frame_addr + get_ebp_ofs(code)
- value = rffi.cast(rffi.LONGP, stackloc)[0]
+ value = rffi.cast(rffi.SIGNEDP, stackloc)[0]
if kind == self.DESCR_FLOAT and WORD == 4:
value_hi = value
- value = rffi.cast(rffi.LONGP, stackloc - 4)[0]
+ value = rffi.cast(rffi.SIGNEDP, stackloc - 4)[0]
else:
# 'code' identifies a register: load its value
kind = code & 3
@@ -2011,10 +2005,10 @@
elif kind == self.DESCR_FLOAT:
tgt = self.fail_boxes_float.get_addr_for_num(num)
if WORD == 4:
- rffi.cast(rffi.LONGP, tgt)[1] = value_hi
+ rffi.cast(rffi.SIGNEDP, tgt)[1] = value_hi
else:
assert 0, "bogus kind"
- rffi.cast(rffi.LONGP, tgt)[0] = value
+ rffi.cast(rffi.SIGNEDP, tgt)[0] = value
num += 1
#
if not we_are_translated():
@@ -2040,7 +2034,7 @@
self.failure_recovery_func = failure_recovery_func
self.failure_recovery_code = [0, 0, 0, 0]
- _FAILURE_RECOVERY_FUNC = lltype.Ptr(lltype.FuncType([rffi.LONGP],
+ _FAILURE_RECOVERY_FUNC = lltype.Ptr(lltype.FuncType([rffi.SIGNEDP],
lltype.Signed))
def _build_failure_recovery(self, exc, withfloats=False):
diff --git a/pypy/jit/backend/x86/codebuf.py b/pypy/jit/backend/x86/codebuf.py
--- a/pypy/jit/backend/x86/codebuf.py
+++ b/pypy/jit/backend/x86/codebuf.py
@@ -48,7 +48,7 @@
if self.relocations is not None:
for reloc in self.relocations:
p = addr + reloc
- adr = rffi.cast(rffi.LONGP, p - WORD)
+ adr = rffi.cast(rffi.SIGNEDP, p - WORD)
adr[0] = intmask(adr[0] - p)
valgrind.discard_translations(addr, self.get_relative_pos())
self._dump(addr, "jit-backend-dump", backend_name)
diff --git a/pypy/jit/backend/x86/regalloc.py b/pypy/jit/backend/x86/regalloc.py
--- a/pypy/jit/backend/x86/regalloc.py
+++ b/pypy/jit/backend/x86/regalloc.py
@@ -1017,8 +1017,6 @@
self.PerformDiscard(op, [base_loc, ofs, itemsize, fieldsize,
index_loc, temp_loc, value_loc])
- consider_setinteriorfield_raw = consider_setinteriorfield_gc
-
def consider_strsetitem(self, op):
args = op.getarglist()
base_loc = self.rm.make_sure_var_in_reg(op.getarg(0), args)
@@ -1110,8 +1108,6 @@
self.Perform(op, [base_loc, ofs, itemsize, fieldsize,
index_loc, temp_loc, sign_loc], result_loc)
- consider_getinteriorfield_raw = consider_getinteriorfield_gc
-
def consider_int_is_true(self, op, guard_op):
# doesn't need arg to be in a register
argloc = self.loc(op.getarg(0))
@@ -1384,11 +1380,8 @@
# i.e. the n'th word beyond the fixed frame size.
return -WORD * (FRAME_FIXED_SIZE + position)
-def _valid_addressing_size(size):
- return size == 1 or size == 2 or size == 4 or size == 8
-
def _get_scale(size):
- assert _valid_addressing_size(size)
+ assert size == 1 or size == 2 or size == 4 or size == 8
if size < 4:
return size - 1 # 1, 2 => 0, 1
else:
diff --git a/pypy/jit/backend/x86/runner.py b/pypy/jit/backend/x86/runner.py
--- a/pypy/jit/backend/x86/runner.py
+++ b/pypy/jit/backend/x86/runner.py
@@ -150,7 +150,7 @@
cast_ptr_to_int._annspecialcase_ = 'specialize:arglltype(0)'
cast_ptr_to_int = staticmethod(cast_ptr_to_int)
- all_null_registers = lltype.malloc(rffi.LONGP.TO, 24,
+ all_null_registers = lltype.malloc(rffi.SIGNEDP.TO, 24,
flavor='raw', zero=True,
immortal=True)
diff --git a/pypy/jit/backend/x86/test/test_assembler.py b/pypy/jit/backend/x86/test/test_assembler.py
--- a/pypy/jit/backend/x86/test/test_assembler.py
+++ b/pypy/jit/backend/x86/test/test_assembler.py
@@ -101,7 +101,7 @@
assert withfloats
value = random.random() - 0.5
# make sure it fits into 64 bits
- tmp = lltype.malloc(rffi.LONGP.TO, 2, flavor='raw',
+ tmp = lltype.malloc(rffi.SIGNEDP.TO, 2, flavor='raw',
track_allocation=False)
rffi.cast(rffi.DOUBLEP, tmp)[0] = value
return rffi.cast(rffi.DOUBLEP, tmp)[0], tmp[0], tmp[1]
@@ -139,11 +139,11 @@
# prepare the expected target arrays, the descr_bytecode,
# the 'registers' and the 'stack' arrays according to 'content'
- xmmregisters = lltype.malloc(rffi.LONGP.TO, 16+ACTUAL_CPU.NUM_REGS+1,
+ xmmregisters = lltype.malloc(rffi.SIGNEDP.TO, 16+ACTUAL_CPU.NUM_REGS+1,
flavor='raw', immortal=True)
registers = rffi.ptradd(xmmregisters, 16)
stacklen = baseloc + 30
- stack = lltype.malloc(rffi.LONGP.TO, stacklen, flavor='raw',
+ stack = lltype.malloc(rffi.SIGNEDP.TO, stacklen, flavor='raw',
immortal=True)
expected_ints = [0] * len(content)
expected_ptrs = [lltype.nullptr(llmemory.GCREF.TO)] * len(content)
diff --git a/pypy/jit/codewriter/effectinfo.py b/pypy/jit/codewriter/effectinfo.py
--- a/pypy/jit/codewriter/effectinfo.py
+++ b/pypy/jit/codewriter/effectinfo.py
@@ -48,8 +48,6 @@
OS_LIBFFI_PREPARE = 60
OS_LIBFFI_PUSH_ARG = 61
OS_LIBFFI_CALL = 62
- OS_LIBFFI_GETARRAYITEM = 63
- OS_LIBFFI_SETARRAYITEM = 64
#
OS_LLONG_INVERT = 69
OS_LLONG_ADD = 70
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
@@ -1615,12 +1615,6 @@
elif oopspec_name.startswith('libffi_call_'):
oopspecindex = EffectInfo.OS_LIBFFI_CALL
extraeffect = EffectInfo.EF_RANDOM_EFFECTS
- elif oopspec_name == 'libffi_array_getitem':
- oopspecindex = EffectInfo.OS_LIBFFI_GETARRAYITEM
- extraeffect = EffectInfo.EF_CANNOT_RAISE
- elif oopspec_name == 'libffi_array_setitem':
- oopspecindex = EffectInfo.OS_LIBFFI_SETARRAYITEM
- extraeffect = EffectInfo.EF_CANNOT_RAISE
else:
assert False, 'unsupported oopspec: %s' % oopspec_name
return self._handle_oopspec_call(op, args, oopspecindex, extraeffect)
diff --git a/pypy/jit/metainterp/executor.py b/pypy/jit/metainterp/executor.py
--- a/pypy/jit/metainterp/executor.py
+++ b/pypy/jit/metainterp/executor.py
@@ -340,8 +340,6 @@
rop.DEBUG_MERGE_POINT,
rop.JIT_DEBUG,
rop.SETARRAYITEM_RAW,
- rop.GETINTERIORFIELD_RAW,
- rop.SETINTERIORFIELD_RAW,
rop.CALL_RELEASE_GIL,
rop.QUASIIMMUT_FIELD,
): # list of opcodes never executed by pyjitpl
diff --git a/pypy/jit/metainterp/optimizeopt/fficall.py b/pypy/jit/metainterp/optimizeopt/fficall.py
--- a/pypy/jit/metainterp/optimizeopt/fficall.py
+++ b/pypy/jit/metainterp/optimizeopt/fficall.py
@@ -1,13 +1,11 @@
+from pypy.rpython.annlowlevel import cast_base_ptr_to_instance
+from pypy.rlib.objectmodel import we_are_translated
+from pypy.rlib.libffi import Func
+from pypy.rlib.debug import debug_print
from pypy.jit.codewriter.effectinfo import EffectInfo
+from pypy.jit.metainterp.resoperation import rop, ResOperation
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
from pypy.jit.metainterp.optimizeopt.optimizer import Optimization
-from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
-from pypy.jit.metainterp.resoperation import rop, ResOperation
-from pypy.rlib import clibffi, libffi
-from pypy.rlib.debug import debug_print
-from pypy.rlib.libffi import Func
-from pypy.rlib.objectmodel import we_are_translated
-from pypy.rpython.annlowlevel import cast_base_ptr_to_instance
-from pypy.rpython.lltypesystem import llmemory
class FuncInfo(object):
@@ -80,7 +78,7 @@
def new(self):
return OptFfiCall()
-
+
def begin_optimization(self, funcval, op):
self.rollback_maybe('begin_optimization', op)
self.funcinfo = FuncInfo(funcval, self.optimizer.cpu, op)
@@ -118,9 +116,6 @@
ops = self.do_push_arg(op)
elif oopspec == EffectInfo.OS_LIBFFI_CALL:
ops = self.do_call(op)
- elif (oopspec == EffectInfo.OS_LIBFFI_GETARRAYITEM or
- oopspec == EffectInfo.OS_LIBFFI_SETARRAYITEM):
- ops = self.do_getsetarrayitem(op, oopspec)
#
for op in ops:
self.emit_operation(op)
@@ -195,53 +190,6 @@
ops.append(newop)
return ops
- def do_getsetarrayitem(self, op, oopspec):
- ffitypeval = self.getvalue(op.getarg(1))
- widthval = self.getvalue(op.getarg(2))
- offsetval = self.getvalue(op.getarg(5))
- if not ffitypeval.is_constant() or not widthval.is_constant() or not offsetval.is_constant():
- return [op]
-
- ffitypeaddr = ffitypeval.box.getaddr()
- ffitype = llmemory.cast_adr_to_ptr(ffitypeaddr, clibffi.FFI_TYPE_P)
- offset = offsetval.box.getint()
- width = widthval.box.getint()
- descr = self._get_interior_descr(ffitype, width, offset)
-
- arglist = [
- self.getvalue(op.getarg(3)).force_box(self.optimizer),
- self.getvalue(op.getarg(4)).force_box(self.optimizer),
- ]
- if oopspec == EffectInfo.OS_LIBFFI_GETARRAYITEM:
- opnum = rop.GETINTERIORFIELD_RAW
- elif oopspec == EffectInfo.OS_LIBFFI_SETARRAYITEM:
- opnum = rop.SETINTERIORFIELD_RAW
- arglist.append(self.getvalue(op.getarg(6)).force_box(self.optimizer))
- else:
- assert False
- return [
- ResOperation(opnum, arglist, op.result, descr=descr),
- ]
-
- def _get_interior_descr(self, ffitype, width, offset):
- kind = libffi.types.getkind(ffitype)
- is_pointer = is_float = is_signed = False
- if ffitype is libffi.types.pointer:
- is_pointer = True
- elif kind == 'i':
- is_signed = True
- elif kind == 'f' or kind == 'I' or kind == 'U':
- # longlongs are treated as floats, see
- # e.g. llsupport/descr.py:getDescrClass
- is_float = True
- else:
- assert False, "unsupported ffitype or kind"
- #
- fieldsize = ffitype.c_size
- return self.optimizer.cpu.interiorfielddescrof_dynamic(
- offset, width, fieldsize, is_pointer, is_float, is_signed
- )
-
def propagate_forward(self, op):
if self.logops is not None:
debug_print(self.logops.repr_of_resop(op))
diff --git a/pypy/jit/metainterp/resoperation.py b/pypy/jit/metainterp/resoperation.py
--- a/pypy/jit/metainterp/resoperation.py
+++ b/pypy/jit/metainterp/resoperation.py
@@ -461,7 +461,6 @@
'GETARRAYITEM_GC/2d',
'GETARRAYITEM_RAW/2d',
'GETINTERIORFIELD_GC/2d',
- 'GETINTERIORFIELD_RAW/2d',
'GETFIELD_GC/1d',
'GETFIELD_RAW/1d',
'_MALLOC_FIRST',
@@ -480,7 +479,6 @@
'SETARRAYITEM_GC/3d',
'SETARRAYITEM_RAW/3d',
'SETINTERIORFIELD_GC/3d',
- 'SETINTERIORFIELD_RAW/3d',
'SETFIELD_GC/2d',
'SETFIELD_RAW/2d',
'STRSETITEM/3',
diff --git a/pypy/jit/metainterp/test/test_fficall.py b/pypy/jit/metainterp/test/test_fficall.py
--- a/pypy/jit/metainterp/test/test_fficall.py
+++ b/pypy/jit/metainterp/test/test_fficall.py
@@ -1,18 +1,19 @@
+
import py
+from pypy.rlib.rarithmetic import r_singlefloat, r_longlong, r_ulonglong
+from pypy.rlib.jit import JitDriver, promote, dont_look_inside
+from pypy.rlib.unroll import unrolling_iterable
+from pypy.rlib.libffi import ArgChain
+from pypy.rlib.libffi import IS_32_BIT
+from pypy.rlib.test.test_libffi import TestLibffiCall as _TestLibffiCall
+from pypy.rpython.lltypesystem import lltype, rffi
+from pypy.rlib.objectmodel import specialize
+from pypy.tool.sourcetools import func_with_new_name
+from pypy.jit.metainterp.test.support import LLJitMixin
-from pypy.jit.metainterp.test.support import LLJitMixin
-from pypy.rlib.jit import JitDriver, promote, dont_look_inside
-from pypy.rlib.libffi import (ArgChain, IS_32_BIT, array_getitem, array_setitem,
- types)
-from pypy.rlib.objectmodel import specialize
-from pypy.rlib.rarithmetic import r_singlefloat, r_longlong, r_ulonglong
-from pypy.rlib.test.test_libffi import TestLibffiCall as _TestLibffiCall
-from pypy.rlib.unroll import unrolling_iterable
-from pypy.rpython.lltypesystem import lltype, rffi
-from pypy.tool.sourcetools import func_with_new_name
+class TestFfiCall(LLJitMixin, _TestLibffiCall):
+ supports_all = False # supports_{floats,longlong,singlefloats}
-
-class FfiCallTests(_TestLibffiCall):
# ===> ../../../rlib/test/test_libffi.py
def call(self, funcspec, args, RESULT, is_struct=False, jitif=[]):
@@ -91,69 +92,6 @@
test_byval_result.__doc__ = _TestLibffiCall.test_byval_result.__doc__
test_byval_result.dont_track_allocations = True
-class FfiLookupTests(object):
- def test_array_fields(self):
- myjitdriver = JitDriver(
- greens = [],
- reds = ["n", "i", "points", "result_point"],
- )
- POINT = lltype.Struct("POINT",
- ("x", lltype.Signed),
- ("y", lltype.Signed),
- )
- def f(points, result_point, n):
- i = 0
- while i < n:
- myjitdriver.jit_merge_point(i=i, points=points, n=n,
- result_point=result_point)
- x = array_getitem(
- types.slong, rffi.sizeof(lltype.Signed) * 2, points, i, 0
- )
- y = array_getitem(
- types.slong, rffi.sizeof(lltype.Signed) * 2, points, i, rffi.sizeof(lltype.Signed)
- )
-
- cur_x = array_getitem(
- types.slong, rffi.sizeof(lltype.Signed) * 2, result_point, 0, 0
- )
- cur_y = array_getitem(
- types.slong, rffi.sizeof(lltype.Signed) * 2, result_point, 0, rffi.sizeof(lltype.Signed)
- )
-
- array_setitem(
- types.slong, rffi.sizeof(lltype.Signed) * 2, result_point, 0, 0, cur_x + x
- )
- array_setitem(
- types.slong, rffi.sizeof(lltype.Signed) * 2, result_point, 0, rffi.sizeof(lltype.Signed), cur_y + y
- )
- i += 1
-
- def main(n):
- with lltype.scoped_alloc(rffi.CArray(POINT), n) as points:
- with lltype.scoped_alloc(rffi.CArray(POINT), 1) as result_point:
- for i in xrange(n):
- points[i].x = i * 2
- points[i].y = i * 2 + 1
- points = rffi.cast(rffi.CArrayPtr(lltype.Char), points)
- result_point[0].x = 0
- result_point[0].y = 0
- result_point = rffi.cast(rffi.CArrayPtr(lltype.Char), result_point)
- f(points, result_point, n)
- result_point = rffi.cast(rffi.CArrayPtr(POINT), result_point)
- return result_point[0].x * result_point[0].y
-
- assert self.meta_interp(main, [10]) == main(10) == 9000
- self.check_loops({"int_add": 3, "jump": 1, "int_lt": 1, "guard_true": 1,
- "getinteriorfield_raw": 4, "setinteriorfield_raw": 2
- })
-
-
-class TestFfiCall(FfiCallTests, LLJitMixin):
- supports_all = False
-
-class TestFfiCallSupportAll(FfiCallTests, LLJitMixin):
+class TestFfiCallSupportAll(TestFfiCall):
supports_all = True # supports_{floats,longlong,singlefloats}
-
-class TestFfiLookup(FfiLookupTests, LLJitMixin):
- pass
\ No newline at end of file
diff --git a/pypy/module/cpyext/include/modsupport.h b/pypy/module/cpyext/include/modsupport.h
--- a/pypy/module/cpyext/include/modsupport.h
+++ b/pypy/module/cpyext/include/modsupport.h
@@ -48,11 +48,7 @@
/*
* This is from pyport.h. Perhaps it belongs elsewhere.
*/
-#ifdef __cplusplus
-#define PyMODINIT_FUNC extern "C" void
-#else
#define PyMODINIT_FUNC void
-#endif
#ifdef __cplusplus
diff --git a/pypy/module/cpyext/presetup.py b/pypy/module/cpyext/presetup.py
--- a/pypy/module/cpyext/presetup.py
+++ b/pypy/module/cpyext/presetup.py
@@ -42,4 +42,4 @@
patch_distutils()
del sys.argv[0]
-execfile(sys.argv[0], {'__file__': sys.argv[0], '__name__': '__main__'})
+execfile(sys.argv[0], {'__file__': sys.argv[0]})
diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py
--- a/pypy/objspace/std/objspace.py
+++ b/pypy/objspace/std/objspace.py
@@ -9,7 +9,7 @@
from pypy.objspace.descroperation import DescrOperation, raiseattrerror
from pypy.rlib.objectmodel import instantiate, r_dict, specialize, is_annotation_constant
from pypy.rlib.debug import make_sure_not_resized
-from pypy.rlib.rarithmetic import base_int, widen
+from pypy.rlib.rarithmetic import base_int, widen, is_valid_int
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib import jit
@@ -160,7 +160,7 @@
if isinstance(x, OperationError):
raise TypeError, ("attempt to wrap already wrapped exception: %s"%
(x,))
- if isinstance(x, int):
+ if isinstance(x, (int, long)) and is_valid_int(x):
if isinstance(x, bool):
return self.newbool(x)
else:
diff --git a/pypy/rlib/_rffi_stacklet.py b/pypy/rlib/_rffi_stacklet.py
--- a/pypy/rlib/_rffi_stacklet.py
+++ b/pypy/rlib/_rffi_stacklet.py
@@ -3,16 +3,32 @@
from pypy.rpython.lltypesystem import lltype, llmemory, rffi
from pypy.translator.tool.cbuild import ExternalCompilationInfo
from pypy.rpython.tool import rffi_platform
+from pypy.rlib.rarithmetic import is_emulated_long
+import sys
cdir = py.path.local(pypydir) / 'translator' / 'c'
-
eci = ExternalCompilationInfo(
include_dirs = [cdir],
includes = ['src/stacklet/stacklet.h'],
separate_module_sources = ['#include "src/stacklet/stacklet.c"\n'],
)
+if sys.platform == 'win32':
+ if is_emulated_long:
+ asmsrc = 'switch_x64_msvc.asm'
+ else:
+ asmsrc = 'switch_x86_msvc.asm'
+ eci.separate_module_files += (cdir / 'src' / 'stacklet' / asmsrc, )
+ eci.export_symbols += (
+ 'stacklet_newthread',
+ 'stacklet_deletethread',
+ 'stacklet_new',
+ 'stacklet_switch',
+ 'stacklet_destroy',
+ '_stacklet_translate_pointer',
+ )
+
rffi_platform.verify_eci(eci.convert_sources_to_files())
def llexternal(name, args, result, **kwds):
diff --git a/pypy/rlib/clibffi.py b/pypy/rlib/clibffi.py
--- a/pypy/rlib/clibffi.py
+++ b/pypy/rlib/clibffi.py
@@ -5,7 +5,7 @@
from pypy.rpython.tool import rffi_platform
from pypy.rpython.lltypesystem import lltype, rffi
from pypy.rlib.unroll import unrolling_iterable
-from pypy.rlib.rarithmetic import intmask, r_uint
+from pypy.rlib.rarithmetic import intmask, r_uint, is_emulated_long
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib.rmmap import alloc
from pypy.rlib.rdynload import dlopen, dlclose, dlsym, dlsym_byordinal
@@ -27,6 +27,7 @@
_MSVC = platform.name == "msvc"
_MINGW = platform.name == "mingw32"
_WIN32 = _MSVC or _MINGW
+_WIN64 = _WIN32 and is_emulated_long
_MAC_OS = platform.name == "darwin"
_FREEBSD_7 = platform.name == "freebsd7"
@@ -116,6 +117,10 @@
])
else:
libffidir = py.path.local(pypydir).join('translator', 'c', 'src', 'libffi_msvc')
+ if not _WIN64:
+ asm_ifc = 'win32.c'
+ else:
+ asm_ifc = 'win64.asm'
eci = ExternalCompilationInfo(
includes = ['ffi.h', 'windows.h'],
libraries = ['kernel32'],
@@ -123,7 +128,7 @@
separate_module_sources = separate_module_sources,
separate_module_files = [libffidir.join('ffi.c'),
libffidir.join('prep_cif.c'),
- libffidir.join('win32.c'),
+ libffidir.join(asm_ifc),
libffidir.join('pypy_ffi.c'),
],
export_symbols = ['ffi_call', 'ffi_prep_cif', 'ffi_prep_closure',
@@ -139,7 +144,7 @@
FFI_OK = rffi_platform.ConstantInteger('FFI_OK')
FFI_BAD_TYPEDEF = rffi_platform.ConstantInteger('FFI_BAD_TYPEDEF')
FFI_DEFAULT_ABI = rffi_platform.ConstantInteger('FFI_DEFAULT_ABI')
- if _WIN32:
+ if _WIN32 and not _WIN64:
FFI_STDCALL = rffi_platform.ConstantInteger('FFI_STDCALL')
FFI_TYPE_STRUCT = rffi_platform.ConstantInteger('FFI_TYPE_STRUCT')
@@ -431,7 +436,7 @@
FUNCFLAG_USE_LASTERROR = 16
def get_call_conv(flags, from_jit):
- if _WIN32 and (flags & FUNCFLAG_CDECL == 0):
+ if _WIN32 and not _WIN64 and (flags & FUNCFLAG_CDECL == 0):
return FFI_STDCALL
else:
return FFI_DEFAULT_ABI
diff --git a/pypy/rlib/debug.py b/pypy/rlib/debug.py
--- a/pypy/rlib/debug.py
+++ b/pypy/rlib/debug.py
@@ -325,7 +325,7 @@
"""Give a translation-time error if 'x' is not a plain int
(e.g. if it's a r_longlong or an r_uint).
"""
- assert type(x) is int
+ assert type(x) in (int, long)
return x
class Entry(ExtRegistryEntry):
diff --git a/pypy/rlib/jit.py b/pypy/rlib/jit.py
--- a/pypy/rlib/jit.py
+++ b/pypy/rlib/jit.py
@@ -450,55 +450,6 @@
# special-cased by ExtRegistryEntry
pass
- def _set_param(self, name, value):
- # special-cased by ExtRegistryEntry
- # (internal, must receive a constant 'name')
- # if value is DEFAULT, sets the default value.
- assert name in PARAMETERS
-
- @specialize.arg(0, 1)
- def set_param(self, name, value):
- """Set one of the tunable JIT parameter."""
- self._set_param(name, value)
-
- @specialize.arg(0, 1)
- def set_param_to_default(self, name):
- """Reset one of the tunable JIT parameters to its default value."""
- self._set_param(name, DEFAULT)
-
- def set_user_param(self, text):
- """Set the tunable JIT parameters from a user-supplied string
- following the format 'param=value,param=value', or 'off' to
- disable the JIT. For programmatic setting of parameters, use
- directly JitDriver.set_param().
- """
- if text == 'off':
- self.set_param('threshold', -1)
- self.set_param('function_threshold', -1)
- return
- if text == 'default':
- for name1, _ in unroll_parameters:
- self.set_param_to_default(name1)
- return
- for s in text.split(','):
- s = s.strip(' ')
- parts = s.split('=')
- if len(parts) != 2:
- raise ValueError
- name = parts[0]
- value = parts[1]
- if name == 'enable_opts':
- self.set_param('enable_opts', value)
- else:
- for name1, _ in unroll_parameters:
- if name1 == name and name1 != 'enable_opts':
- try:
- self.set_param(name1, int(value))
- except ValueError:
- raise
- set_user_param._annspecialcase_ = 'specialize:arg(0)'
-
-
def on_compile(self, logger, looptoken, operations, type, *greenargs):
""" A hook called when loop is compiled. Overwrite
for your own jitdriver if you want to do something special, like
@@ -524,16 +475,61 @@
self.jit_merge_point = self.jit_merge_point
self.can_enter_jit = self.can_enter_jit
self.loop_header = self.loop_header
- self._set_param = self._set_param
-
class Entry(ExtEnterLeaveMarker):
_about_ = (self.jit_merge_point, self.can_enter_jit)
class Entry(ExtLoopHeader):
_about_ = self.loop_header
- class Entry(ExtSetParam):
- _about_ = self._set_param
+def _set_param(driver, name, value):
+ # special-cased by ExtRegistryEntry
+ # (internal, must receive a constant 'name')
+ # if value is DEFAULT, sets the default value.
+ assert name in PARAMETERS
+
+ at specialize.arg(0, 1)
+def set_param(driver, name, value):
+ """Set one of the tunable JIT parameter. Driver can be None, then all
+ drivers have this set """
+ _set_param(driver, name, value)
+
+ at specialize.arg(0, 1)
+def set_param_to_default(driver, name):
+ """Reset one of the tunable JIT parameters to its default value."""
+ _set_param(driver, name, DEFAULT)
+
+def set_user_param(driver, text):
+ """Set the tunable JIT parameters from a user-supplied string
+ following the format 'param=value,param=value', or 'off' to
+ disable the JIT. For programmatic setting of parameters, use
+ directly JitDriver.set_param().
+ """
+ if text == 'off':
+ set_param(driver, 'threshold', -1)
+ set_param(driver, 'function_threshold', -1)
+ return
+ if text == 'default':
+ for name1, _ in unroll_parameters:
+ set_param_to_default(driver, name1)
+ return
+ for s in text.split(','):
+ s = s.strip(' ')
+ parts = s.split('=')
+ if len(parts) != 2:
+ raise ValueError
+ name = parts[0]
+ value = parts[1]
+ if name == 'enable_opts':
+ set_param(driver, 'enable_opts', value)
+ else:
+ for name1, _ in unroll_parameters:
+ if name1 == name and name1 != 'enable_opts':
+ try:
+ set_param(driver, name1, int(value))
+ except ValueError:
+ raise
+set_user_param._annspecialcase_ = 'specialize:arg(0)'
+
# ____________________________________________________________
#
@@ -705,8 +701,9 @@
resulttype=lltype.Void)
class ExtSetParam(ExtRegistryEntry):
+ _about_ = _set_param
- def compute_result_annotation(self, s_name, s_value):
+ def compute_result_annotation(self, s_driver, s_name, s_value):
from pypy.annotation import model as annmodel
assert s_name.is_constant()
if not self.bookkeeper.immutablevalue(DEFAULT).contains(s_value):
@@ -722,21 +719,22 @@
from pypy.objspace.flow.model import Constant
hop.exception_cannot_occur()
- driver = self.instance.im_self
- name = hop.args_s[0].const
+ driver = hop.inputarg(lltype.Void, arg=0)
+ name = hop.args_s[1].const
if name == 'enable_opts':
repr = string_repr
else:
repr = lltype.Signed
- if (isinstance(hop.args_v[1], Constant) and
- hop.args_v[1].value is DEFAULT):
+ if (isinstance(hop.args_v[2], Constant) and
+ hop.args_v[2].value is DEFAULT):
value = PARAMETERS[name]
v_value = hop.inputconst(repr, value)
else:
- v_value = hop.inputarg(repr, arg=1)
+ v_value = hop.inputarg(repr, arg=2)
vlist = [hop.inputconst(lltype.Void, "set_param"),
- hop.inputconst(lltype.Void, driver),
+ driver,
hop.inputconst(lltype.Void, name),
v_value]
return hop.genop('jit_marker', vlist,
resulttype=lltype.Void)
+
diff --git a/pypy/rlib/rarithmetic.py b/pypy/rlib/rarithmetic.py
--- a/pypy/rlib/rarithmetic.py
+++ b/pypy/rlib/rarithmetic.py
@@ -30,22 +30,54 @@
"""
-import sys
+import sys, struct
from pypy.rpython import extregistry
from pypy.rlib import objectmodel
-# set up of machine internals
-_bits = 0
-_itest = 1
-_Ltest = 1L
-while _itest == _Ltest and type(_itest) is int:
- _itest *= 2
- _Ltest *= 2
- _bits += 1
+"""
+Long-term target:
+We want to make pypy very flexible concerning its data type layout.
+This is a larger task for later.
-LONG_BIT = _bits+1
-LONG_MASK = _Ltest*2-1
-LONG_TEST = _Ltest
+Short-term target:
+We want to run PyPy on windows 64 bit.
+
+Problem:
+On windows 64 bit, integers are only 32 bit. This is a problem for PyPy
+right now, since it assumes that a c long can hold a pointer.
+We therefore set up the target machine constants to obey this rule.
+Right now this affects 64 bit Python only on windows.
+
+Note: We use the struct module, because the array module doesn's support
+all typecodes.
+"""
+
+def _get_bitsize(typecode):
+ return len(struct.pack(typecode, 1)) * 8
+
+_long_typecode = 'l'
+if _get_bitsize('P') > _get_bitsize('l'):
+ _long_typecode = 'P'
+
+def _get_long_bit():
+ # whatever size a long has, make it big enough for a pointer.
+ return _get_bitsize(_long_typecode)
+
+# exported for now for testing array values.
+# might go into its own module.
+def get_long_pattern(x):
+ """get the bit pattern for a long, adjusted to pointer size"""
+ return struct.pack(_long_typecode, x)
+
+# used in tests for ctypes and for genc and friends
+# to handle the win64 special case:
+is_emulated_long = _long_typecode <> 'l'
+
+LONG_BIT = _get_long_bit()
+LONG_MASK = (2**LONG_BIT)-1
+LONG_TEST = 2**(LONG_BIT-1)
+
+# XXX this is a good guess, but what if a long long is 128 bit?
LONGLONG_BIT = 64
LONGLONG_MASK = (2**LONGLONG_BIT)-1
LONGLONG_TEST = 2**(LONGLONG_BIT-1)
@@ -55,17 +87,23 @@
LONG_BIT_SHIFT += 1
assert LONG_BIT_SHIFT < 99, "LONG_BIT_SHIFT value not found?"
+"""
+int is no longer necessarily the same size as the target int.
+We therefore can no longer use the int type as it is, but need
+to use long everywhere.
+"""
+
def intmask(n):
- if isinstance(n, int):
- return int(n) # possibly bool->int
if isinstance(n, objectmodel.Symbolic):
return n # assume Symbolics don't overflow
assert not isinstance(n, float)
+ if is_valid_int(n):
+ return int(n)
n = long(n)
n &= LONG_MASK
if n >= LONG_TEST:
n -= 2*LONG_TEST
- return int(n)
+ return n
def longlongmask(n):
assert isinstance(n, (int, long))
@@ -95,7 +133,8 @@
r_class.BITS == LONG_BIT and r_class.SIGNED)
_should_widen_type._annspecialcase_ = 'specialize:memo'
-del _bits, _itest, _Ltest
+def is_valid_int(r):
+ return -sys.maxint - 1 <= r <= sys.maxint
def ovfcheck(r):
"NOT_RPYTHON"
@@ -103,8 +142,10 @@
# raise OverflowError if the operation did overflow
assert not isinstance(r, r_uint), "unexpected ovf check on unsigned"
assert not isinstance(r, r_longlong), "ovfcheck not supported on r_longlong"
- assert not isinstance(r,r_ulonglong),"ovfcheck not supported on r_ulonglong"
- if type(r) is long:
+ assert not isinstance(r, r_ulonglong), "ovfcheck not supported on r_ulonglong"
+ if type(r) is long and not is_valid_int(r):
+ # the type check is needed to make ovfcheck skip symbolics.
+ # this happens in the garbage collector.
raise OverflowError, "signed integer expression did overflow"
return r
@@ -416,6 +457,9 @@
r_longlong = build_int('r_longlong', True, 64)
r_ulonglong = build_int('r_ulonglong', False, 64)
+r_long = build_int('r_long', True, 32)
+r_ulong = build_int('r_ulong', False, 32)
+
longlongmax = r_longlong(LONGLONG_TEST - 1)
if r_longlong is not r_int:
@@ -423,6 +467,14 @@
else:
r_int64 = int
+# needed for ll_os_stat.time_t_to_FILE_TIME in the 64 bit case
+if r_long is not r_int:
+ r_uint32 = r_ulong
+else:
+ r_uint32 = r_uint
+
+# needed for ll_time.time_sleep_llimpl
+maxint32 = int((1 << 31) -1)
# the 'float' C type
diff --git a/pypy/rlib/rbigint.py b/pypy/rlib/rbigint.py
--- a/pypy/rlib/rbigint.py
+++ b/pypy/rlib/rbigint.py
@@ -1,5 +1,5 @@
from pypy.rlib.rarithmetic import LONG_BIT, intmask, r_uint, r_ulonglong
-from pypy.rlib.rarithmetic import ovfcheck, r_longlong, widen
+from pypy.rlib.rarithmetic import ovfcheck, r_longlong, widen, is_valid_int
from pypy.rlib.rarithmetic import most_neg_value_of_same_type
from pypy.rlib.rfloat import isfinite
from pypy.rlib.debug import make_sure_not_resized, check_regular_int
@@ -44,21 +44,19 @@
def _mask_digit(x):
- if not we_are_translated():
- assert type(x) is not long, "overflow occurred!"
return intmask(x & MASK)
_mask_digit._annspecialcase_ = 'specialize:argtype(0)'
def _widen_digit(x):
if not we_are_translated():
- assert type(x) is int, "widen_digit() takes an int, got a %r" % type(x)
+ assert type(x) in (int, long) and is_valid_int(x), "widen_digit() takes an int, got a %r" % type(x)
if SHIFT <= 15:
return int(x)
return r_longlong(x)
def _store_digit(x):
if not we_are_translated():
- assert type(x) is int, "store_digit() takes an int, got a %r" % type(x)
+ assert type(x) in (int, long) and is_valid_int(x), "store_digit() takes an int, got a %r" % type(x)
if SHIFT <= 15:
return rffi.cast(rffi.SHORT, x)
elif SHIFT <= 31:
diff --git a/pypy/rlib/rdtoa.py b/pypy/rlib/rdtoa.py
--- a/pypy/rlib/rdtoa.py
+++ b/pypy/rlib/rdtoa.py
@@ -58,8 +58,8 @@
try:
result = dg_strtod(ll_input, end_ptr)
- endpos = (rffi.cast(rffi.LONG, end_ptr[0]) -
- rffi.cast(rffi.LONG, ll_input))
+ endpos = (rffi.cast(lltype.Signed, end_ptr[0]) -
+ rffi.cast(lltype.Signed, ll_input))
if endpos == 0 or endpos < len(input):
raise ValueError("invalid input at position %d" % (endpos,))
@@ -244,8 +244,8 @@
# The only failure mode is no memory
raise MemoryError
try:
- buflen = (rffi.cast(rffi.LONG, end_ptr[0]) -
- rffi.cast(rffi.LONG, digits))
+ buflen = (rffi.cast(lltype.Signed, end_ptr[0]) -
+ rffi.cast(lltype.Signed, digits))
sign = rffi.cast(lltype.Signed, sign_ptr[0])
# Handle nan and inf
diff --git a/pypy/rlib/rerased.py b/pypy/rlib/rerased.py
--- a/pypy/rlib/rerased.py
+++ b/pypy/rlib/rerased.py
@@ -28,7 +28,7 @@
def erase_int(x):
- assert isinstance(x, int)
+ assert isinstance(x, (int, long))
res = 2 * x + 1
if res > sys.maxint or res < -sys.maxint - 1:
raise OverflowError
@@ -36,7 +36,7 @@
def unerase_int(y):
assert y._identity is _identity_for_ints
- assert isinstance(y._x, int)
+ assert isinstance(y._x, (int, long))
return y._x
diff --git a/pypy/rpython/llinterp.py b/pypy/rpython/llinterp.py
--- a/pypy/rpython/llinterp.py
+++ b/pypy/rpython/llinterp.py
@@ -1018,22 +1018,25 @@
# Overflow-detecting variants
def op_int_neg_ovf(self, x):
- assert type(x) is int
+ # assert type(x) is int
+ assert isinstance(x, (int, long))
try:
return ovfcheck(-x)
except OverflowError:
self.make_llexception()
def op_int_abs_ovf(self, x):
- assert type(x) is int
+ # assert type(x) is int
+ assert isinstance(x, (int, long))
try:
return ovfcheck(abs(x))
except OverflowError:
self.make_llexception()
def op_int_lshift_ovf(self, x, y):
- assert isinstance(x, int)
- assert isinstance(y, int)
+ # win64: int or long because target size differs
+ assert isinstance(x, (int, long))
+ assert isinstance(y, (int, long))
try:
return ovfcheck(x << y)
except OverflowError:
@@ -1074,15 +1077,15 @@
self.make_llexception()
""" % locals()).compile() in globals(), d
- _makefunc2('op_int_add_ovf', '+', '(int, llmemory.AddressOffset)')
- _makefunc2('op_int_mul_ovf', '*', '(int, llmemory.AddressOffset)', 'int')
- _makefunc2('op_int_sub_ovf', '-', 'int')
- _makefunc2('op_int_floordiv_ovf', '//', 'int') # XXX negative args
- _makefunc2('op_int_floordiv_zer', '//', 'int') # can get off-by-one
- _makefunc2('op_int_floordiv_ovf_zer', '//', 'int') # (see op_int_floordiv)
- _makefunc2('op_int_mod_ovf', '%', 'int')
- _makefunc2('op_int_mod_zer', '%', 'int')
- _makefunc2('op_int_mod_ovf_zer', '%', 'int')
+ _makefunc2('op_int_add_ovf', '+', '(int, long, llmemory.AddressOffset)')
+ _makefunc2('op_int_mul_ovf', '*', '(int, long, llmemory.AddressOffset)', '(int, long)')
+ _makefunc2('op_int_sub_ovf', '-', '(int, long)')
+ _makefunc2('op_int_floordiv_ovf', '//', '(int, long)') # XXX negative args
+ _makefunc2('op_int_floordiv_zer', '//', '(int, long)') # can get off-by-one
+ _makefunc2('op_int_floordiv_ovf_zer', '//', '(int, long)') # (see op_int_floordiv)
+ _makefunc2('op_int_mod_ovf', '%', '(int, long)')
+ _makefunc2('op_int_mod_zer', '%', '(int, long)')
+ _makefunc2('op_int_mod_ovf_zer', '%', '(int, long)')
_makefunc2('op_uint_floordiv_zer', '//', 'r_uint')
_makefunc2('op_uint_mod_zer', '%', 'r_uint')
@@ -1104,7 +1107,7 @@
x = x.default
# if type(x) is a subclass of Symbolic, bool(x) will usually raise
# a TypeError -- unless __nonzero__ has been explicitly overridden.
- assert isinstance(x, (int, Symbolic))
+ assert isinstance(x, (int, long, Symbolic))
return bool(x)
# hack for jit.codegen.llgraph
diff --git a/pypy/rpython/lltypesystem/ll2ctypes.py b/pypy/rpython/lltypesystem/ll2ctypes.py
--- a/pypy/rpython/lltypesystem/ll2ctypes.py
+++ b/pypy/rpython/lltypesystem/ll2ctypes.py
@@ -15,6 +15,7 @@
load_library_kwargs = {}
import os
+from pypy import conftest
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython.extfunc import ExtRegistryEntry
from pypy.rlib.objectmodel import Symbolic, ComputedIntSymbolic
@@ -176,6 +177,17 @@
assert max_n >= 0
ITEM = A.OF
ctypes_item = get_ctypes_type(ITEM, delayed_builders)
+ # Python 2.5 ctypes can raise OverflowError on 64-bit builds
+ for n in [sys.maxint, 2**31]:
+ MAX_SIZE = n/64
+ try:
+ PtrType = ctypes.POINTER(MAX_SIZE * ctypes_item)
+ except (OverflowError, AttributeError), e:
+ pass # ^^^ bah, blame ctypes
+ else:
+ break
+ else:
+ raise e
class CArray(ctypes.Structure):
if not A._hints.get('nolength'):
@@ -207,6 +219,9 @@
cls._ptrtype = ctypes.POINTER(cls.MAX_SIZE * ctypes_item)
except OverflowError, e:
pass
+ except AttributeError, e:
+ pass # XXX win64 failure and segfault, afterwards:
+ # AttributeError: class must define a '_length_' attribute, which must be a positive integer
else:
break
else:
diff --git a/pypy/rpython/lltypesystem/llmemory.py b/pypy/rpython/lltypesystem/llmemory.py
--- a/pypy/rpython/lltypesystem/llmemory.py
+++ b/pypy/rpython/lltypesystem/llmemory.py
@@ -57,7 +57,7 @@
return "<ItemOffset %r %r>" % (self.TYPE, self.repeat)
def __mul__(self, other):
- if not isinstance(other, int):
+ if not isinstance(other, (int, long)):
return NotImplemented
return ItemOffset(self.TYPE, self.repeat * other)
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
@@ -1,7 +1,8 @@
import py
from pypy.rlib.rarithmetic import (r_int, r_uint, intmask, r_singlefloat,
r_ulonglong, r_longlong, r_longfloat,
- base_int, normalizedinttype, longlongmask)
+ base_int, normalizedinttype, longlongmask,
+ r_uint32)
from pypy.rlib.objectmodel import Symbolic
from pypy.tool.uid import Hashable
from pypy.tool.identity_dict import identity_dict
@@ -1654,7 +1655,7 @@
__slots__ = ('items',)
def __init__(self, TYPE, n, initialization=None, parent=None, parentindex=None):
- if not isinstance(n, int):
+ if not isinstance(n, (int, long)):
raise TypeError, "array length must be an int"
if n < 0:
raise ValueError, "negative array length"
@@ -1723,7 +1724,7 @@
class _subarray(_parentable): # only for direct_fieldptr()
# and direct_arrayitems()
_kind = "subarray"
- _cache = weakref.WeakKeyDictionary() # parentarray -> {subarrays}
+ _cache = {} # TYPE -> weak{ parentarray -> {subarrays} }
def __init__(self, TYPE, parent, baseoffset_or_fieldname):
_parentable.__init__(self, TYPE)
@@ -1781,10 +1782,15 @@
def _makeptr(parent, baseoffset_or_fieldname, solid=False):
try:
- cache = _subarray._cache.setdefault(parent, {})
+ d = _subarray._cache[parent._TYPE]
+ except KeyError:
+ d = _subarray._cache[parent._TYPE] = weakref.WeakKeyDictionary()
+ try:
+ cache = d.setdefault(parent, {})
except RuntimeError: # pointer comparison with a freed structure
_subarray._cleanup_cache()
- cache = _subarray._cache.setdefault(parent, {}) # try again
+ # try again
+ return _subarray._makeptr(parent, baseoffset_or_fieldname, solid)
try:
subarray = cache[baseoffset_or_fieldname]
except KeyError:
@@ -1805,14 +1811,18 @@
raise NotImplementedError('_subarray._getid()')
def _cleanup_cache():
- newcache = weakref.WeakKeyDictionary()
- for key, value in _subarray._cache.items():
- try:
- if not key._was_freed():
- newcache[key] = value
- except RuntimeError:
- pass # ignore "accessing subxxx, but already gc-ed parent"
- _subarray._cache = newcache
+ for T, d in _subarray._cache.items():
+ newcache = weakref.WeakKeyDictionary()
+ for key, value in d.items():
+ try:
+ if not key._was_freed():
+ newcache[key] = value
+ except RuntimeError:
+ pass # ignore "accessing subxxx, but already gc-ed parent"
+ if newcache:
+ _subarray._cache[T] = newcache
+ else:
+ del _subarray._cache[T]
_cleanup_cache = staticmethod(_cleanup_cache)
diff --git a/pypy/rpython/lltypesystem/opimpl.py b/pypy/rpython/lltypesystem/opimpl.py
--- a/pypy/rpython/lltypesystem/opimpl.py
+++ b/pypy/rpython/lltypesystem/opimpl.py
@@ -22,14 +22,14 @@
from pypy.rpython.lltypesystem.llmemory import AddressAsInt
if r_longlong is r_int:
- r_longlong_arg = (r_longlong, int)
- r_longlong_result = int
+ r_longlong_arg = (r_longlong, int, long)
+ r_longlong_result = long # XXX was int
else:
r_longlong_arg = r_longlong
r_longlong_result = r_longlong
argtype_by_name = {
- 'int': int,
+ 'int': (int, long),
'float': float,
'uint': r_uint,
'llong': r_longlong_arg,
@@ -173,7 +173,7 @@
def op_direct_ptradd(obj, index):
checkptr(obj)
- assert isinstance(index, int)
+ assert isinstance(index, (int, long))
return lltype.direct_ptradd(obj, index)
@@ -182,29 +182,30 @@
return not b
def op_int_add(x, y):
- if not isinstance(x, (int, llmemory.AddressOffset)):
+ if not isinstance(x, (int, long, llmemory.AddressOffset)):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, (int, llmemory.AddressOffset))
+ assert isinstance(y, (int, long, llmemory.AddressOffset))
return intmask(x + y)
def op_int_sub(x, y):
- if not isinstance(x, int):
+ if not isinstance(x, (int, long)):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return intmask(x - y)
def op_int_ge(x, y):
# special case for 'AddressOffset >= 0'
- assert isinstance(x, (int, llmemory.AddressOffset))
- assert isinstance(y, int)
+ assert isinstance(x, (int, long, llmemory.AddressOffset))
+ assert isinstance(y, (int, long))
return x >= y
def op_int_lt(x, y):
# special case for 'AddressOffset < 0'
- assert isinstance(x, (int, llmemory.AddressOffset))
- assert isinstance(y, int)
+ # hack for win64
+ assert isinstance(x, (int, long, llmemory.AddressOffset))
+ assert isinstance(y, (int, long))
return x < y
def op_int_between(a, b, c):
@@ -214,50 +215,51 @@
return a <= b < c
def op_int_and(x, y):
- if not isinstance(x, int):
+ if not isinstance(x, (int, long)):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return x & y
def op_int_or(x, y):
- if not isinstance(x, int):
+ if not isinstance(x, (int, long)):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return x | y
def op_int_xor(x, y):
# used in computing hashes
if isinstance(x, AddressAsInt): x = llmemory.cast_adr_to_int(x.adr)
if isinstance(y, AddressAsInt): y = llmemory.cast_adr_to_int(y.adr)
- assert isinstance(x, int)
- assert isinstance(y, int)
+ assert isinstance(x, (int, long))
+ assert isinstance(y, (int, long))
return x ^ y
def op_int_mul(x, y):
- assert isinstance(x, (int, llmemory.AddressOffset))
- assert isinstance(y, (int, llmemory.AddressOffset))
+ assert isinstance(x, (int, long, llmemory.AddressOffset))
+ assert isinstance(y, (int, long, llmemory.AddressOffset))
return intmask(x * y)
def op_int_rshift(x, y):
- if not isinstance(x, int):
+ if not isinstance(x, (int, long)):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return x >> y
def op_int_floordiv(x, y):
- assert isinstance(x, (int, llmemory.AddressOffset))
- assert isinstance(y, (int, llmemory.AddressOffset))
+ # hack for win64
+ assert isinstance(x, (int, long, llmemory.AddressOffset))
+ assert isinstance(y, (int, long, llmemory.AddressOffset))
r = x//y
if x^y < 0 and x%y != 0:
r += 1
return r
def op_int_mod(x, y):
- assert isinstance(x, (int, llmemory.AddressOffset))
- assert isinstance(y, (int, llmemory.AddressOffset))
+ assert isinstance(x, (int, long, llmemory.AddressOffset))
+ assert isinstance(y, (int, long, llmemory.AddressOffset))
r = x%y
if x^y < 0 and x%y != 0:
r -= y
@@ -281,22 +283,22 @@
def op_uint_lshift(x, y):
assert isinstance(x, r_uint)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return r_uint(x << y)
def op_uint_rshift(x, y):
assert isinstance(x, r_uint)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return r_uint(x >> y)
def op_llong_lshift(x, y):
assert isinstance(x, r_longlong_arg)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return r_longlong_result(x << y)
def op_llong_rshift(x, y):
assert isinstance(x, r_longlong_arg)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return r_longlong_result(x >> y)
def op_ullong_lshift(x, y):
@@ -306,7 +308,7 @@
def op_ullong_rshift(x, y):
assert isinstance(x, r_ulonglong)
- assert isinstance(y, int)
+ assert isinstance(y, (int, long))
return r_ulonglong(x >> y)
def op_same_as(x):
@@ -318,7 +320,8 @@
op_cast_primitive.need_result_type = True
def op_cast_int_to_float(i):
- assert type(i) is int
+ # assert type(i) is int
+ assert isinstance(i, (int, long))
return float(i)
def op_cast_uint_to_float(u):
@@ -340,7 +343,8 @@
return ui + li
def op_cast_int_to_char(b):
- assert type(b) is int
+ #assert type(b) is int
+ assert isinstance(b, (int, long))
return chr(b)
def op_cast_bool_to_int(b):
@@ -384,11 +388,12 @@
return ord(b)
def op_cast_int_to_unichar(b):
- assert type(b) is int
+ assert isinstance(b, (int, long))
return unichr(b)
def op_cast_int_to_uint(b):
- assert type(b) is int
+ # assert type(b) is int
+ assert isinstance(b, (int, long))
return r_uint(b)
def op_cast_uint_to_int(b):
@@ -396,7 +401,7 @@
return intmask(b)
def op_cast_int_to_longlong(b):
- assert type(b) is int
+ assert isinstance(b, (int, long))
return r_longlong_result(b)
def op_truncate_longlong_to_int(b):
@@ -567,7 +572,7 @@
if isinstance(memberoffset, llgroup.GroupMemberOffset):
return memberoffset.index != 0
else:
- assert isinstance(memberoffset, int)
+ assert isinstance(memberoffset, (int, long))
return memberoffset != 0
def op_extract_ushort(combinedoffset):
diff --git a/pypy/rpython/lltypesystem/rbuilder.py b/pypy/rpython/lltypesystem/rbuilder.py
--- a/pypy/rpython/lltypesystem/rbuilder.py
+++ b/pypy/rpython/lltypesystem/rbuilder.py
@@ -123,9 +123,10 @@
def ll_build(ll_builder):
final_size = ll_builder.used
assert final_size >= 0
- if final_size == ll_builder.allocated:
- return ll_builder.buf
- return rgc.ll_shrink_array(ll_builder.buf, final_size)
+ if final_size < ll_builder.allocated:
+ ll_builder.allocated = final_size
+ ll_builder.buf = rgc.ll_shrink_array(ll_builder.buf, final_size)
+ return ll_builder.buf
@classmethod
def ll_is_true(cls, ll_builder):
diff --git a/pypy/rpython/lltypesystem/rffi.py b/pypy/rpython/lltypesystem/rffi.py
--- a/pypy/rpython/lltypesystem/rffi.py
+++ b/pypy/rpython/lltypesystem/rffi.py
@@ -17,6 +17,7 @@
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib.rstring import StringBuilder, UnicodeBuilder
from pypy.rpython.lltypesystem import llmemory
+from pypy.rlib.rarithmetic import LONG_BIT
import os, sys
class CConstant(Symbolic):
@@ -646,6 +647,9 @@
# float *
FLOATP = lltype.Ptr(lltype.Array(FLOAT, hints={'nolength': True}))
+# Signed *
+SIGNEDP = lltype.Ptr(lltype.Array(lltype.Signed, hints={'nolength': True}))
+
# various type mapping
# conversions between str and char*
@@ -864,7 +868,7 @@
except AttributeError:
if not isinstance(tp, lltype.Primitive):
unsigned = False
- elif tp in (lltype.Signed, FLOAT, DOUBLE):
+ elif tp in (lltype.Signed, FLOAT, DOUBLE, llmemory.Address):
unsigned = False
elif tp in (lltype.Char, lltype.UniChar, lltype.Bool):
unsigned = True
@@ -887,7 +891,7 @@
size = llmemory.sizeof(tp) # a symbolic result in this case
return size
if isinstance(tp, lltype.Ptr) or tp is llmemory.Address:
- tp = ULONG # XXX!
+ tp = lltype.Signed
if tp is lltype.Char or tp is lltype.Bool:
return 1
if tp is lltype.UniChar:
@@ -898,7 +902,7 @@
return 4
assert isinstance(tp, lltype.Number)
if tp is lltype.Signed:
- return ULONG._type.BITS/8
+ return LONG_BIT/8
return tp._type.BITS/8
sizeof._annspecialcase_ = 'specialize:memo'
@@ -918,11 +922,14 @@
offsetof._annspecialcase_ = 'specialize:memo'
# check that we have a sane configuration
-assert sys.maxint == (1 << (8 * sizeof(lltype.Signed) - 1)) - 1, (
+# XXX re-enable this after correcting the windows case
+"""
+assert maxint == (1 << (8 * sizeof(lltype.Signed) - 1)) - 1, (
"Mixed configuration of the word size of the machine:\n\t"
"the underlying Python was compiled with maxint=%d,\n\t"
"but the C compiler says that 'long' is %d bytes" % (
- sys.maxint, sizeof(lltype.Signed)))
+ maxint, sizeof(lltype.Signed)))
+"""
# ********************** some helpers *******************
diff --git a/pypy/rpython/lltypesystem/test/test_ll2ctypes.py b/pypy/rpython/lltypesystem/test/test_ll2ctypes.py
--- a/pypy/rpython/lltypesystem/test/test_ll2ctypes.py
+++ b/pypy/rpython/lltypesystem/test/test_ll2ctypes.py
@@ -16,12 +16,27 @@
from pypy.rpython.test.test_llinterp import interpret
from pypy.annotation.annrpython import RPythonAnnotator
from pypy.rpython.rtyper import RPythonTyper
-
+from pypy.rlib.rarithmetic import r_uint, get_long_pattern, is_emulated_long
if False: # for now, please keep it False by default
from pypy.rpython.lltypesystem import ll2ctypes
ll2ctypes.do_allocation_in_far_regions()
+"""
+Win64:
+To decouple the cpython machine level long from the faked integer
+of the target rpython, I replaced most 'lltype.Signed' by 'rffi.LONG'.
+It would be nicer to replace all lltypes constants by rffi equivalents,
+or better if we had a way to address the specific different types of
+the current and the target system layout explicitly.
+Let's think of that when we go further and make the target completely
+independent and configurable.
+Why most and not all replaced?
+Tests with direct tests become cumbersome, instead of direct number
+assignment rffi.setintfield(s, 'x', 123) must be used.
+So in cases with number constants, where the size is not relevant,
+I kept lltype.signed .
+"""
class TestLL2Ctypes(object):
@@ -33,7 +48,7 @@
assert lltype2ctypes('?') == ord('?')
assert lltype2ctypes('\xE0') == 0xE0
assert lltype2ctypes(unichr(1234)) == 1234
- assert ctypes2lltype(lltype.Signed, 5) == 5
+ assert ctypes2lltype(rffi.LONG, 5) == 5
assert ctypes2lltype(lltype.Char, ord('a')) == 'a'
assert ctypes2lltype(lltype.UniChar, ord(u'x')) == u'x'
assert ctypes2lltype(lltype.Char, 0xFF) == '\xFF'
@@ -46,15 +61,15 @@
res = ctypes2lltype(lltype.SingleFloat, ctypes.c_float(-3.5))
assert isinstance(res, rffi.r_singlefloat)
assert float(res) == -3.5
- assert lltype2ctypes(rffi.r_ulong(-1)) == sys.maxint * 2 + 1
+ assert lltype2ctypes(rffi.r_ulong(-1)) == (1 << rffi.r_ulong.BITS) - 1
res = ctypes2lltype(lltype.Unsigned, sys.maxint * 2 + 1)
- assert (res, type(res)) == (rffi.r_ulong(-1), rffi.r_ulong)
+ assert (res, type(res)) == (r_uint(-1), r_uint)
assert ctypes2lltype(lltype.Bool, 0) is False
assert ctypes2lltype(lltype.Bool, 1) is True
- res = lltype2ctypes(llmemory.sizeof(lltype.Signed))
+ res = lltype2ctypes(llmemory.sizeof(rffi.LONG))
assert res == struct.calcsize("l")
- S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed))
+ S = lltype.Struct('S', ('x', rffi.LONG), ('y', rffi.LONG))
res = lltype2ctypes(llmemory.sizeof(S))
assert res == struct.calcsize("ll")
@@ -69,7 +84,7 @@
def test_simple_struct(self):
S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed))
s = lltype.malloc(S, flavor='raw')
- s.x = 123
+ rffi.setintfield(s, 'x', 123)
sc = lltype2ctypes(s)
assert isinstance(sc.contents, ctypes.Structure)
assert sc.contents.x == 123
@@ -144,7 +159,7 @@
def test_array_inside_struct(self):
# like rstr.STR, but not Gc
- STR = lltype.Struct('STR', ('x', lltype.Signed), ('y', lltype.Array(lltype.Char)))
+ STR = lltype.Struct('STR', ('x', rffi.LONG), ('y', lltype.Array(lltype.Char)))
a = lltype.malloc(STR, 3, flavor='raw')
a.y[0] = 'x'
a.y[1] = 'y'
@@ -171,7 +186,7 @@
assert a[2] == 456
a[3] = 789
assert ac.contents.items[3] == 789
- assert ctypes.sizeof(ac.contents) == 10 * ctypes.sizeof(ctypes.c_long)
+ assert ctypes.sizeof(ac.contents) == 10 * rffi.sizeof(lltype.Signed)
lltype.free(a, flavor='raw')
assert not ALLOCATED # detects memory leaks in the test
@@ -223,20 +238,20 @@
def test_func_not_in_clib(self):
eci = ExternalCompilationInfo(libraries=['m'])
- foobar = rffi.llexternal('I_really_dont_exist', [], lltype.Signed)
+ foobar = rffi.llexternal('I_really_dont_exist', [], rffi.LONG)
py.test.raises(NotImplementedError, foobar)
- foobar = rffi.llexternal('I_really_dont_exist', [], lltype.Signed,
+ foobar = rffi.llexternal('I_really_dont_exist', [], rffi.LONG,
compilation_info=eci) # math library
py.test.raises(NotImplementedError, foobar)
eci = ExternalCompilationInfo(libraries=['m', 'z'])
- foobar = rffi.llexternal('I_really_dont_exist', [], lltype.Signed,
+ foobar = rffi.llexternal('I_really_dont_exist', [], rffi.LONG,
compilation_info=eci) # math and zlib
py.test.raises(NotImplementedError, foobar)
eci = ExternalCompilationInfo(libraries=['I_really_dont_exist_either'])
- foobar = rffi.llexternal('I_really_dont_exist', [], lltype.Signed,
+ foobar = rffi.llexternal('I_really_dont_exist', [], rffi.LONG,
compilation_info=eci)
py.test.raises(NotImplementedError, foobar)
assert not ALLOCATED # detects memory leaks in the test
@@ -399,10 +414,9 @@
b = rffi.cast(lltype.Ptr(B), a)
- checker = array.array('l')
+ expected = ''
for i in range(10):
- checker.append(i*i)
- expected = checker.tostring()
+ expected += get_long_pattern(i*i)
for i in range(len(expected)):
assert b[i] == expected[i]
@@ -418,7 +432,7 @@
assert e[i] == i*i
c = lltype.nullptr(rffi.VOIDP.TO)
- addr = rffi.cast(lltype.Signed, c)
+ addr = rffi.cast(rffi.LONG, c)
assert addr == 0
lltype.free(a, flavor='raw')
@@ -444,8 +458,13 @@
FUNCTYPE = lltype.FuncType([lltype.Signed], lltype.Signed)
cdummy = lltype2ctypes(llhelper(lltype.Ptr(FUNCTYPE), dummy))
- assert isinstance(cdummy,
- ctypes.CFUNCTYPE(ctypes.c_long, ctypes.c_long))
+ if not is_emulated_long:
+ assert isinstance(cdummy,
+ ctypes.CFUNCTYPE(ctypes.c_long, ctypes.c_long))
+ else:
+ # XXX maybe we skip this if it breaks on some platforms
+ assert isinstance(cdummy,
+ ctypes.CFUNCTYPE(ctypes.c_longlong, ctypes.c_longlong))
res = cdummy(41)
assert res == 42
lldummy = ctypes2lltype(lltype.Ptr(FUNCTYPE), cdummy)
@@ -455,7 +474,7 @@
assert not ALLOCATED # detects memory leaks in the test
def test_funcptr2(self):
- FUNCTYPE = lltype.FuncType([rffi.CCHARP], lltype.Signed)
+ FUNCTYPE = lltype.FuncType([rffi.CCHARP], rffi.LONG)
cstrlen = standard_c_lib.strlen
llstrlen = ctypes2lltype(lltype.Ptr(FUNCTYPE), cstrlen)
assert lltype.typeOf(llstrlen) == lltype.Ptr(FUNCTYPE)
@@ -545,8 +564,9 @@
checkval(uninitialized2ctypes(rffi.CHAR), 'B')
checkval(uninitialized2ctypes(rffi.SHORT), 'h')
- checkval(uninitialized2ctypes(rffi.INT), 'i')
- checkval(uninitialized2ctypes(rffi.UINT), 'I')
+ if not is_emulated_long:
+ checkval(uninitialized2ctypes(rffi.INT), 'i')
+ checkval(uninitialized2ctypes(rffi.UINT), 'I')
checkval(uninitialized2ctypes(rffi.LONGLONG), 'q')
checkval(uninitialized2ctypes(rffi.DOUBLE), 'd')
checkobj(uninitialized2ctypes(rffi.INTP),
@@ -554,7 +574,7 @@
checkobj(uninitialized2ctypes(rffi.CCHARP),
ctypes.sizeof(ctypes.c_void_p))
- S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed))
+ S = lltype.Struct('S', ('x', rffi.LONG), ('y', rffi.LONG))
s = lltype.malloc(S, flavor='raw')
sc = lltype2ctypes(s)
checkval(sc.contents.x, 'l')
@@ -717,9 +737,13 @@
assert not ALLOCATED # detects memory leaks in the test
def test_get_errno(self):
+ # win64: works with python 2.6.7, but not with 2.7.2
+ # XXX check what is different with ctypes!
eci = ExternalCompilationInfo(includes=['string.h'])
if sys.platform.startswith('win'):
underscore_on_windows = '_'
+ if sys.version.startswith('2.7.2 '):
+ py.test.skip('ctypes is buggy. errno crashes with win64 and python 2.7.2')
else:
underscore_on_windows = ''
strlen = rffi.llexternal('strlen', [rffi.CCHARP], rffi.SIZE_T,
@@ -730,7 +754,7 @@
buffer = lltype.malloc(rffi.CCHARP.TO, 5, flavor='raw')
written = os_write(12312312, buffer, 5)
lltype.free(buffer, flavor='raw')
- assert rffi.cast(lltype.Signed, written) < 0
+ assert rffi.cast(rffi.LONG, written) < 0
# the next line is a random external function call,
# to check that it doesn't reset errno
strlen("hi!")
@@ -849,9 +873,9 @@
return one + get_x()
def fy():
- one = rffi.cast(lltype.Signed, get_y())
+ one = rffi.cast(rffi.LONG, get_y())
set_y(rffi.cast(rffi.INT, 13))
- return one + rffi.cast(lltype.Signed, get_y())
+ return one + rffi.cast(rffi.LONG, get_y())
def g():
l = rffi.liststr2charpp(["a", "b", "c"])
@@ -916,7 +940,7 @@
lltype.free(a, flavor='raw')
def test_array_type_bug(self):
- A = lltype.Array(lltype.Signed)
+ A = lltype.Array(rffi.LONG)
a1 = lltype.malloc(A, 0, flavor='raw')
a2 = lltype.malloc(A, 0, flavor='raw')
c1 = lltype2ctypes(a1)
@@ -1006,7 +1030,7 @@
def test_recursive_struct_more(self):
NODE = lltype.ForwardReference()
- NODE.become(lltype.Struct('NODE', ('value', lltype.Signed),
+ NODE.become(lltype.Struct('NODE', ('value', rffi.LONG),
('next', lltype.Ptr(NODE))))
CNODEPTR = get_ctypes_type(NODE)
pc = CNODEPTR()
@@ -1034,11 +1058,11 @@
assert p.pong.ping == p
def test_typedef(self):
- assert ctypes2lltype(lltype.Typedef(lltype.Signed, 'test'), 6) == 6
+ assert ctypes2lltype(lltype.Typedef(rffi.LONG, 'test'), 6) == 6
assert ctypes2lltype(lltype.Typedef(lltype.Float, 'test2'), 3.4) == 3.4
- assert get_ctypes_type(lltype.Signed) == get_ctypes_type(
- lltype.Typedef(lltype.Signed, 'test3'))
+ assert get_ctypes_type(rffi.LONG) == get_ctypes_type(
+ lltype.Typedef(rffi.LONG, 'test3'))
def test_cast_adr_to_int(self):
class someaddr(object):
@@ -1046,7 +1070,7 @@
return sys.maxint/2 * 3
res = cast_adr_to_int(someaddr())
- assert isinstance(res, int)
+ assert isinstance(res, (int, long))
assert res == -sys.maxint/2 - 3
def test_cast_gcref_back_and_forth(self):
@@ -1299,7 +1323,7 @@
p = lltype.malloc(S, flavor='raw')
a = llmemory.cast_ptr_to_adr(p)
i = llmemory.cast_adr_to_int(a, "forced")
- assert type(i) is int
+ assert isinstance(i, (int, long))
assert i == llmemory.cast_adr_to_int(a, "forced")
lltype.free(p, flavor='raw')
diff --git a/pypy/rpython/memory/gc/inspector.py b/pypy/rpython/memory/gc/inspector.py
--- a/pypy/rpython/memory/gc/inspector.py
+++ b/pypy/rpython/memory/gc/inspector.py
@@ -109,7 +109,7 @@
self.gc = gc
self.gcflag = gc.gcflag_extra
self.fd = rffi.cast(rffi.INT, fd)
- self.writebuffer = lltype.malloc(rffi.LONGP.TO, self.BUFSIZE,
+ self.writebuffer = lltype.malloc(rffi.SIGNEDP.TO, self.BUFSIZE,
flavor='raw')
self.buf_count = 0
if self.gcflag == 0:
diff --git a/pypy/rpython/memory/gctransform/asmgcroot.py b/pypy/rpython/memory/gctransform/asmgcroot.py
--- a/pypy/rpython/memory/gctransform/asmgcroot.py
+++ b/pypy/rpython/memory/gctransform/asmgcroot.py
@@ -533,10 +533,11 @@
# The initial gcmap table contains addresses to a JMP
# instruction that jumps indirectly to the real code.
# Replace them with the target addresses.
+ assert rffi.SIGNEDP is rffi.LONGP, "win64 support missing"
while start < end:
code = rffi.cast(rffi.CCHARP, start.address[0])[0]
if code == '\xe9': # jmp
- rel32 = rffi.cast(rffi.LONGP, start.address[0]+1)[0]
+ rel32 = rffi.cast(rffi.SIGNEDP, start.address[0]+1)[0]
target = start.address[0] + (rel32 + 5)
start.address[0] = target
start += arrayitemsize
diff --git a/pypy/rpython/memory/lltypelayout.py b/pypy/rpython/memory/lltypelayout.py
--- a/pypy/rpython/memory/lltypelayout.py
+++ b/pypy/rpython/memory/lltypelayout.py
@@ -1,4 +1,5 @@
from pypy.rpython.lltypesystem import lltype, llmemory, llarena
+from pypy.rlib.rarithmetic import is_emulated_long
import struct
@@ -12,7 +13,11 @@
lltype.Float: "d",
llmemory.Address: "P",
}
-
+if is_emulated_long:
+ primitive_to_fmt.update( {
+ lltype.Signed: "q",
+ lltype.Unsigned: "Q",
+ } )
#___________________________________________________________________________
# Utility functions that know about the memory layout of the lltypes
diff --git a/pypy/rpython/memory/test/test_transformed_gc.py b/pypy/rpython/memory/test/test_transformed_gc.py
--- a/pypy/rpython/memory/test/test_transformed_gc.py
+++ b/pypy/rpython/memory/test/test_transformed_gc.py
@@ -737,7 +737,7 @@
def f():
from pypy.rpython.lltypesystem import rffi
alist = [A() for i in range(50)]
- idarray = lltype.malloc(rffi.LONGP.TO, len(alist), flavor='raw')
+ idarray = lltype.malloc(rffi.SIGNEDP.TO, len(alist), flavor='raw')
# Compute the id of all the elements of the list. The goal is
# to not allocate memory, so that if the GC needs memory to
# remember the ids, it will trigger some collections itself
diff --git a/pypy/rpython/module/ll_os.py b/pypy/rpython/module/ll_os.py
--- a/pypy/rpython/module/ll_os.py
+++ b/pypy/rpython/module/ll_os.py
@@ -428,9 +428,13 @@
UTIMBUFP = lltype.Ptr(self.UTIMBUF)
os_utime = self.llexternal('utime', [rffi.CCHARP, UTIMBUFP], rffi.INT)
+ if not _WIN32:
+ includes = ['sys/time.h']
+ else:
+ includes = ['time.h']
class CConfig:
_compilation_info_ = ExternalCompilationInfo(
- includes=['sys/time.h']
+ includes=includes
)
HAVE_UTIMES = platform.Has('utimes')
config = platform.configure(CConfig)
@@ -440,9 +444,14 @@
if config['HAVE_UTIMES']:
class CConfig:
- _compilation_info_ = ExternalCompilationInfo(
- includes = ['sys/time.h']
- )
+ if not _WIN32:
+ _compilation_info_ = ExternalCompilationInfo(
+ includes = ['sys/time.h']
+ )
+ else:
+ _compilation_info_ = ExternalCompilationInfo(
+ includes = ['time.h']
+ )
TIMEVAL = platform.Struct('struct timeval', [('tv_sec', rffi.LONG),
('tv_usec', rffi.LONG)])
config = platform.configure(CConfig)
@@ -547,10 +556,10 @@
# The fields of a FILETIME structure are the hi and lo parts
# of a 64-bit value expressed in 100 nanosecond units
# (of course).
- result = (pkernel.c_dwHighDateTime*429.4967296 +
- pkernel.c_dwLowDateTime*1E-7,
- puser.c_dwHighDateTime*429.4967296 +
- puser.c_dwLowDateTime*1E-7,
+ result = (rffi.cast(lltype.Signed, pkernel.c_dwHighDateTime) * 429.4967296 +
+ rffi.cast(lltype.Signed, pkernel.c_dwLowDateTime) * 1E-7,
+ rffi.cast(lltype.Signed, puser.c_dwHighDateTime) * 429.4967296 +
+ rffi.cast(lltype.Signed, puser.c_dwLowDateTime) * 1E-7,
0, 0, 0)
lltype.free(puser, flavor='raw')
lltype.free(pkernel, flavor='raw')
@@ -808,7 +817,7 @@
[traits.CCHARP, rffi.INT, rffi.MODE_T],
rffi.INT)
def os_open_llimpl(path, flags, mode):
- result = rffi.cast(rffi.LONG, os_open(path, flags, mode))
+ result = rffi.cast(lltype.Signed, os_open(path, flags, mode))
if result == -1:
raise OSError(rposix.get_errno(), "os_open failed")
return result
@@ -1334,7 +1343,7 @@
os_isatty = self.llexternal(underscore_on_windows+'isatty', [rffi.INT], rffi.INT)
def isatty_llimpl(fd):
- res = rffi.cast(rffi.LONG, os_isatty(rffi.cast(rffi.INT, fd)))
+ res = rffi.cast(lltype.Signed, os_isatty(rffi.cast(rffi.INT, fd)))
return res != 0
return extdef([int], bool, llimpl=isatty_llimpl,
diff --git a/pypy/rpython/module/ll_os_stat.py b/pypy/rpython/module/ll_os_stat.py
--- a/pypy/rpython/module/ll_os_stat.py
+++ b/pypy/rpython/module/ll_os_stat.py
@@ -319,6 +319,7 @@
assert len(STAT_FIELDS) == 10 # no extra fields on Windows
def attributes_to_mode(attributes):
+ attributes = lltype.r_uint(attributes)
m = 0
if attributes & win32traits.FILE_ATTRIBUTE_DIRECTORY:
m |= win32traits._S_IFDIR | 0111 # IFEXEC for user,group,other
@@ -456,6 +457,6 @@
def time_t_to_FILE_TIME(time, filetime):
ft = lltype.r_longlong((time + secs_between_epochs) * 10000000)
- filetime.c_dwHighDateTime = lltype.r_uint(ft >> 32)
- filetime.c_dwLowDateTime = lltype.r_uint(ft & lltype.r_uint(-1))
+ filetime.c_dwHighDateTime = lltype.r_uint32(ft >> 32)
+ filetime.c_dwLowDateTime = lltype.r_uint32(ft & lltype.r_uint(-1))
diff --git a/pypy/rpython/module/ll_time.py b/pypy/rpython/module/ll_time.py
--- a/pypy/rpython/module/ll_time.py
+++ b/pypy/rpython/module/ll_time.py
@@ -9,7 +9,7 @@
from pypy.rpython.lltypesystem import lltype
from pypy.rpython.extfunc import BaseLazyRegistering, registering, extdef
from pypy.rlib import rposix
-from pypy.rlib.rarithmetic import intmask
+from pypy.rlib.rarithmetic import intmask, maxint32
from pypy.translator.tool.cbuild import ExternalCompilationInfo
if sys.platform == 'win32':
@@ -177,7 +177,7 @@
@registering(time.sleep)
def register_time_sleep(self):
if sys.platform == 'win32':
- MAX = sys.maxint
+ MAX = maxint32
Sleep = self.llexternal('Sleep', [rffi.ULONG], lltype.Void)
def time_sleep_llimpl(secs):
millisecs = secs * 1000.0
diff --git a/pypy/rpython/module/test/test_ll_os.py b/pypy/rpython/module/test/test_ll_os.py
--- a/pypy/rpython/module/test/test_ll_os.py
+++ b/pypy/rpython/module/test/test_ll_os.py
@@ -80,8 +80,12 @@
pwd = os.getcwd()
import ctypes
buf = ctypes.create_string_buffer(1000)
- ctypes.windll.kernel32.GetEnvironmentVariableA('=%c:' % pwd[0], buf, 1000)
- assert str(buf.value) == pwd
+ len = ctypes.windll.kernel32.GetEnvironmentVariableA('=%c:' % pwd[0], buf, 1000)
+ if (len == 0) and "WINGDB_PYTHON" in os.environ:
+ # the ctypes call seems not to work in the Wing debugger
+ return
+ assert str(buf.value).lower() == pwd
+ # ctypes returns the drive letter in uppercase, os.getcwd does not
pwd = os.getcwd()
try:
diff --git a/pypy/rpython/module/test/test_ll_os_stat.py b/pypy/rpython/module/test/test_ll_os_stat.py
--- a/pypy/rpython/module/test/test_ll_os_stat.py
+++ b/pypy/rpython/module/test/test_ll_os_stat.py
@@ -26,7 +26,7 @@
assert wstat(unicode(f)).st_mtime == expected
check('c:/')
- check('c:/temp')
+ check(os.environ['TEMP'])
check('c:/pagefile.sys')
def test_fstat(self):
diff --git a/pypy/rpython/module/test/test_posix.py b/pypy/rpython/module/test/test_posix.py
--- a/pypy/rpython/module/test/test_posix.py
+++ b/pypy/rpython/module/test/test_posix.py
@@ -18,10 +18,10 @@
def test_open(self):
def f():
- ff = posix.open(path,posix.O_RDONLY,0777)
+ ff = posix.open(path, posix.O_RDONLY, 0777)
return ff
- func = self.interpret(f,[])
- assert type(func) == int
+ func = self.interpret(f, [])
+ assert isinstance(func, (int, long))
def test_fstat(self):
def fo(fi):
@@ -65,21 +65,21 @@
def test_lseek(self):
- def f(fi,pos):
- posix.lseek(fi,pos,0)
- fi = os.open(path,os.O_RDONLY,0777)
- func = self.interpret(f,[fi,5])
- res = os.read(fi,2)
+ def f(fi, pos):
+ posix.lseek(fi, pos, 0)
+ fi = os.open(path, os.O_RDONLY, 0777)
+ func = self.interpret(f, [fi, 5])
+ res = os.read(fi, 2)
assert res =='is'
def test_isatty(self):
def f(fi):
posix.isatty(fi)
- fi = os.open(path,os.O_RDONLY,0777)
- func = self.interpret(f,[fi])
+ fi = os.open(path, os.O_RDONLY, 0777)
+ func = self.interpret(f, [fi])
assert not func
os.close(fi)
- func = self.interpret(f,[fi])
+ func = self.interpret(f, [fi])
assert not func
def test_getcwd(self):
diff --git a/pypy/rpython/rint.py b/pypy/rpython/rint.py
--- a/pypy/rpython/rint.py
+++ b/pypy/rpython/rint.py
@@ -7,7 +7,8 @@
SignedLongLong, build_number, Number, cast_primitive, typeOf
from pypy.rpython.rmodel import IntegerRepr, inputconst
from pypy.rpython.robject import PyObjRepr, pyobj_repr
-from pypy.rlib.rarithmetic import intmask, r_int, r_uint, r_ulonglong, r_longlong
+from pypy.rlib.rarithmetic import intmask, r_int, r_uint, r_ulonglong, \
+ r_longlong, is_emulated_long
from pypy.rpython.error import TyperError, MissingRTypeOperation
from pypy.rpython.rmodel import log
from pypy.rlib import objectmodel
@@ -440,6 +441,11 @@
Unsigned: ('RPyLong_AsUnsignedLong', lambda pyo: r_uint(pyo._obj.value)),
Signed: ('PyInt_AsLong', lambda pyo: int(pyo._obj.value))
}
+if is_emulated_long: # win64
+ py_to_ll_conversion_functions.update( {
+ Unsigned: ('RPyLong_AsUnsignedLongLong', lambda pyo: r_ulonglong(pyo._obj.value)),
+ Signed: ('RPyLong_AsLongLong', lambda pyo: r_longlong(pyo._obj.value)),
+ } )
ll_to_py_conversion_functions = {
UnsignedLongLong: ('PyLong_FromUnsignedLongLong', lambda i: pyobjectptr(i)),
@@ -447,6 +453,11 @@
Unsigned: ('PyLong_FromUnsignedLong', lambda i: pyobjectptr(i)),
Signed: ('PyInt_FromLong', lambda i: pyobjectptr(i)),
}
+if is_emulated_long: # win64
+ ll_to_py_conversion_functions.update( {
+ Unsigned: ('PyLong_FromUnsignedLongLong', lambda i: pyobjectptr(i)),
+ Signed: ('PyLong_FromLongLong', lambda i: pyobjectptr(i)),
+ } )
class __extend__(pairtype(PyObjRepr, IntegerRepr)):
diff --git a/pypy/rpython/rmodel.py b/pypy/rpython/rmodel.py
--- a/pypy/rpython/rmodel.py
+++ b/pypy/rpython/rmodel.py
@@ -339,11 +339,11 @@
def _get_opprefix(self):
if self._opprefix is None:
- raise TyperError("arithmetic not supported on %r" %
+ raise TyperError("arithmetic not supported on %r, it's size is too small" %
self.lowleveltype)
return self._opprefix
- opprefix =property(_get_opprefix)
+ opprefix = property(_get_opprefix)
class BoolRepr(IntegerRepr):
lowleveltype = Bool
diff --git a/pypy/rpython/test/test_rbuilder.py b/pypy/rpython/test/test_rbuilder.py
--- a/pypy/rpython/test/test_rbuilder.py
+++ b/pypy/rpython/test/test_rbuilder.py
@@ -1,3 +1,4 @@
+from __future__ import with_statement
import py
from pypy.rlib.rstring import StringBuilder, UnicodeBuilder
diff --git a/pypy/test_all.py b/pypy/test_all.py
--- a/pypy/test_all.py
+++ b/pypy/test_all.py
@@ -10,6 +10,10 @@
For more information, use test_all.py -h.
"""
import sys, os
+# XXX hack for win64:
+# this needs to be done without hacking maxint
+if hasattr(sys, "maxsize"):
+ sys.maxint = max(sys.maxint, sys.maxsize)
if len(sys.argv) == 1 and os.path.dirname(sys.argv[0]) in '.':
print >> sys.stderr, __doc__
diff --git a/pypy/translator/c/primitive.py b/pypy/translator/c/primitive.py
--- a/pypy/translator/c/primitive.py
+++ b/pypy/translator/c/primitive.py
@@ -1,7 +1,7 @@
import sys
from pypy.rlib.objectmodel import Symbolic, ComputedIntSymbolic
from pypy.rlib.objectmodel import CDefinedIntSymbolic
-from pypy.rlib.rarithmetic import r_longlong
+from pypy.rlib.rarithmetic import r_longlong, is_emulated_long
from pypy.rlib.rfloat import isinf, isnan
from pypy.rpython.lltypesystem.lltype import *
from pypy.rpython.lltypesystem import rffi, llgroup
@@ -16,6 +16,15 @@
#
# Primitives
+# win64: we need different constants, since we emulate 64 bit long.
+# this function simply replaces 'L' by 'LL' in a format string
+if is_emulated_long:
+ def lll(fmt):
+ return fmt.replace('L', 'LL')
+else:
+ def lll(fmt):
+ return fmt
+
def name_signed(value, db):
if isinstance(value, Symbolic):
if isinstance(value, FieldOffset):
@@ -61,22 +70,22 @@
elif isinstance(value, llgroup.CombinedSymbolic):
name = name_small_integer(value.lowpart, db)
assert (value.rest & value.MASK) == 0
- return '(%s+%dL)' % (name, value.rest)
+ return lll('(%s+%dL)') % (name, value.rest)
elif isinstance(value, AddressAsInt):
- return '((long)%s)' % name_address(value.adr, db)
+ return '((Signed)%s)' % name_address(value.adr, db)
else:
raise Exception("unimplemented symbolic %r"%value)
if value is None:
assert not db.completed
return None
if value == -sys.maxint-1: # blame C
- return '(-%dL-1L)' % sys.maxint
+ return lll('(-%dL-1L)') % sys.maxint
else:
- return '%dL' % value
+ return lll('%dL') % value
def name_unsigned(value, db):
assert value >= 0
- return '%dUL' % value
+ return lll('%dUL') % value
def name_unsignedlonglong(value, db):
assert value >= 0
@@ -172,6 +181,7 @@
# On 64 bit machines, SignedLongLong and Signed are the same, so the
# order matters, because we want the Signed implementation.
+# (some entries collapse during dict creation)
PrimitiveName = {
SignedLongLong: name_signedlonglong,
Signed: name_signed,
@@ -190,9 +200,9 @@
PrimitiveType = {
SignedLongLong: 'long long @',
- Signed: 'long @',
+ Signed: 'Signed @',
UnsignedLongLong: 'unsigned long long @',
- Unsigned: 'unsigned long @',
+ Unsigned: 'Unsigned @',
Float: 'double @',
SingleFloat: 'float @',
LongFloat: 'long double @',
diff --git a/pypy/translator/c/src/address.h b/pypy/translator/c/src/address.h
--- a/pypy/translator/c/src/address.h
+++ b/pypy/translator/c/src/address.h
@@ -16,5 +16,5 @@
#define OP_ADR_LT(x,y,r) r = ((x) < (y))
#define OP_ADR_GE(x,y,r) r = ((x) >= (y))
-#define OP_CAST_ADR_TO_INT(x, mode, r) r = ((long)x)
+#define OP_CAST_ADR_TO_INT(x, mode, r) r = ((Signed)x)
#define OP_CAST_INT_TO_ADR(x, r) r = ((void *)(x))
diff --git a/pypy/translator/c/src/asm_gcc_x86_64.h b/pypy/translator/c/src/asm_gcc_x86_64.h
--- a/pypy/translator/c/src/asm_gcc_x86_64.h
+++ b/pypy/translator/c/src/asm_gcc_x86_64.h
@@ -2,7 +2,7 @@
*/
#define READ_TIMESTAMP(val) do { \
- unsigned long _rax, _rdx; \
+ Unsigned _rax, _rdx; \
asm volatile("rdtsc" : "=a"(_rax), "=d"(_rdx)); \
val = (_rdx << 32) | _rax; \
} while (0)
diff --git a/pypy/translator/c/src/float.h b/pypy/translator/c/src/float.h
--- a/pypy/translator/c/src/float.h
+++ b/pypy/translator/c/src/float.h
@@ -31,8 +31,8 @@
/*** conversions ***/
-#define OP_CAST_FLOAT_TO_INT(x,r) r = (long)(x)
-#define OP_CAST_FLOAT_TO_UINT(x,r) r = (unsigned long)(x)
+#define OP_CAST_FLOAT_TO_INT(x,r) r = (Signed)(x)
+#define OP_CAST_FLOAT_TO_UINT(x,r) r = (Unsigned)(x)
#define OP_CAST_INT_TO_FLOAT(x,r) r = (double)(x)
#define OP_CAST_UINT_TO_FLOAT(x,r) r = (double)(x)
#define OP_CAST_LONGLONG_TO_FLOAT(x,r) r = (double)(x)
diff --git a/pypy/translator/c/src/g_prerequisite.h b/pypy/translator/c/src/g_prerequisite.h
--- a/pypy/translator/c/src/g_prerequisite.h
+++ b/pypy/translator/c/src/g_prerequisite.h
@@ -2,13 +2,21 @@
/**************************************************************/
/*** this is included before any code produced by genc.py ***/
-
#ifdef PYPY_STANDALONE
# include "src/commondefs.h"
#else
# include "Python.h"
#endif
+#ifdef _WIN64
+# define Signed __int64
+# define SIGNED_MIN LLONG_MIN
+#else
+# define Signed long
+# define SIGNED_MIN LONG_MIN
+#endif
+#define Unsigned unsigned Signed
+
#ifdef _WIN32
# include <io.h> /* needed, otherwise _lseeki64 truncates to 32-bits (??) */
#endif
diff --git a/pypy/translator/c/src/int.h b/pypy/translator/c/src/int.h
--- a/pypy/translator/c/src/int.h
+++ b/pypy/translator/c/src/int.h
@@ -5,18 +5,31 @@
/*** unary operations ***/
+/************ win64 support:
+
+ 'Signed' must be defined as
+
+ __int64 in case of win64
+ long in all other cases
+
+ 'SIGNED_MIN' must be defined as
+
+ LLONG_MIN in case of win64
+ LONG_MIN in all other cases
+ */
+
#define OP_INT_IS_TRUE(x,r) r = ((x) != 0)
#define OP_INT_INVERT(x,r) r = ~(x)
#define OP_INT_NEG(x,r) r = -(x)
#define OP_INT_NEG_OVF(x,r) \
- if ((x) == LONG_MIN) FAIL_OVF("integer negate"); \
+ if ((x) == SIGNED_MIN) FAIL_OVF("integer negate"); \
OP_INT_NEG(x,r)
#define OP_INT_ABS(x,r) r = (x) >= 0 ? x : -(x)
#define OP_INT_ABS_OVF(x,r) \
- if ((x) == LONG_MIN) FAIL_OVF("integer absolute"); \
+ if ((x) == SIGNED_MIN) FAIL_OVF("integer absolute"); \
OP_INT_ABS(x,r)
/*** binary operations ***/
@@ -33,8 +46,8 @@
for the case of a == 0 (both subtractions are then constant-folded).
Note that the following line only works if a <= c in the first place,
which we assume is true. */
-#define OP_INT_BETWEEN(a,b,c,r) r = (((unsigned long)b - (unsigned long)a) \
- < ((unsigned long)c - (unsigned long)a))
+#define OP_INT_BETWEEN(a,b,c,r) r = (((Unsigned)b - (Unsigned)a) \
+ < ((Unsigned)c - (Unsigned)a))
/* addition, subtraction */
@@ -42,22 +55,22 @@
/* cast to avoid undefined behaviour on overflow */
#define OP_INT_ADD_OVF(x,y,r) \
- r = (long)((unsigned long)x + y); \
+ r = (Signed)((Unsigned)x + y); \
if ((r^x) < 0 && (r^y) < 0) FAIL_OVF("integer addition")
#define OP_INT_ADD_NONNEG_OVF(x,y,r) /* y can be assumed >= 0 */ \
- r = (long)((unsigned long)x + y); \
+ r = (Signed)((Unsigned)x + y); \
if ((r&~x) < 0) FAIL_OVF("integer addition")
#define OP_INT_SUB(x,y,r) r = (x) - (y)
#define OP_INT_SUB_OVF(x,y,r) \
- r = (long)((unsigned long)x - y); \
+ r = (Signed)((Unsigned)x - y); \
if ((r^x) < 0 && (r^~y) < 0) FAIL_OVF("integer subtraction")
#define OP_INT_MUL(x,y,r) r = (x) * (y)
-#if SIZEOF_LONG * 2 <= SIZEOF_LONG_LONG
+#if SIZEOF_LONG * 2 <= SIZEOF_LONG_LONG && !defined(_WIN64)
#define OP_INT_MUL_OVF(x,y,r) \
{ \
long long _lr = (long long)x * y; \
@@ -78,7 +91,7 @@
#define OP_INT_RSHIFT(x,y,r) CHECK_SHIFT_RANGE(y, PYPY_LONG_BIT); \
- r = Py_ARITHMETIC_RIGHT_SHIFT(long, x, (y))
+ r = Py_ARITHMETIC_RIGHT_SHIFT(Signed, x, (y))
#define OP_UINT_RSHIFT(x,y,r) CHECK_SHIFT_RANGE(y, PYPY_LONG_BIT); \
r = (x) >> (y)
#define OP_LLONG_RSHIFT(x,y,r) CHECK_SHIFT_RANGE(y, PYPY_LONGLONG_BIT); \
@@ -98,7 +111,7 @@
#define OP_INT_LSHIFT_OVF(x,y,r) \
OP_INT_LSHIFT(x,y,r); \
- if ((x) != Py_ARITHMETIC_RIGHT_SHIFT(long, r, (y))) \
+ if ((x) != Py_ARITHMETIC_RIGHT_SHIFT(Signed, r, (y))) \
FAIL_OVF("x<<y losing bits or changing sign")
/* floor division */
@@ -109,7 +122,7 @@
#define OP_ULLONG_FLOORDIV(x,y,r) r = (x) / (y)
#define OP_INT_FLOORDIV_OVF(x,y,r) \
- if ((y) == -1 && (x) == LONG_MIN) \
+ if ((y) == -1 && (x) == SIGNED_MIN) \
{ FAIL_OVF("integer division"); r=0; } \
else \
r = (x) / (y)
@@ -149,7 +162,7 @@
#define OP_ULLONG_MOD(x,y,r) r = (x) % (y)
#define OP_INT_MOD_OVF(x,y,r) \
- if ((y) == -1 && (x) == LONG_MIN) \
+ if ((y) == -1 && (x) == SIGNED_MIN) \
{ FAIL_OVF("integer modulo"); r=0; } \
else \
r = (x) % (y)
@@ -188,18 +201,18 @@
/*** conversions ***/
-#define OP_CAST_BOOL_TO_INT(x,r) r = (long)(x)
-#define OP_CAST_BOOL_TO_UINT(x,r) r = (unsigned long)(x)
-#define OP_CAST_UINT_TO_INT(x,r) r = (long)(x)
-#define OP_CAST_INT_TO_UINT(x,r) r = (unsigned long)(x)
+#define OP_CAST_BOOL_TO_INT(x,r) r = (Signed)(x)
+#define OP_CAST_BOOL_TO_UINT(x,r) r = (Unsigned)(x)
+#define OP_CAST_UINT_TO_INT(x,r) r = (Signed)(x)
+#define OP_CAST_INT_TO_UINT(x,r) r = (Unsigned)(x)
#define OP_CAST_INT_TO_LONGLONG(x,r) r = (long long)(x)
-#define OP_CAST_CHAR_TO_INT(x,r) r = (long)((unsigned char)(x))
+#define OP_CAST_CHAR_TO_INT(x,r) r = (Signed)((unsigned char)(x))
#define OP_CAST_INT_TO_CHAR(x,r) r = (char)(x)
-#define OP_CAST_PTR_TO_INT(x,r) r = (long)(x) /* XXX */
+#define OP_CAST_PTR_TO_INT(x,r) r = (Signed)(x) /* XXX */
-#define OP_TRUNCATE_LONGLONG_TO_INT(x,r) r = (long)(x)
+#define OP_TRUNCATE_LONGLONG_TO_INT(x,r) r = (Signed)(x)
-#define OP_CAST_UNICHAR_TO_INT(x,r) r = (long)((unsigned long)(x)) /*?*/
+#define OP_CAST_UNICHAR_TO_INT(x,r) r = (Signed)((Unsigned)(x)) /*?*/
#define OP_CAST_INT_TO_UNICHAR(x,r) r = (unsigned int)(x)
/* bool operations */
diff --git a/pypy/translator/c/src/mem.h b/pypy/translator/c/src/mem.h
--- a/pypy/translator/c/src/mem.h
+++ b/pypy/translator/c/src/mem.h
@@ -53,7 +53,7 @@
extern void* __gcmapstart;
extern void* __gcmapend;
extern char* __gccallshapes;
-extern long pypy_asm_stackwalk(void*, void*);
+extern Signed pypy_asm_stackwalk(void*, void*);
/* With the msvc Microsoft Compiler, the optimizer seems free to move
any code (even asm) that involves local memory (registers and stack).
@@ -66,7 +66,7 @@
pypy_asm_gcroot(void* _r1)
{
static volatile int _constant_always_one_ = 1;
- (long)_r1 *= _constant_always_one_;
+ (Signed)_r1 *= _constant_always_one_;
_ReadWriteBarrier();
return _r1;
}
@@ -86,7 +86,7 @@
/* used by pypy.rlib.rstack, but also by asmgcc */
-#define OP_STACK_CURRENT(r) r = (long)&r
+#define OP_STACK_CURRENT(r) r = (Signed)&r
#define RAW_MALLOC_ZERO_FILLED 0
diff --git a/pypy/translator/c/src/obmalloc.c b/pypy/translator/c/src/obmalloc.c
--- a/pypy/translator/c/src/obmalloc.c
+++ b/pypy/translator/c/src/obmalloc.c
@@ -224,10 +224,10 @@
#define uint unsigned int /* assuming >= 16 bits */
#undef ulong
-#define ulong unsigned long /* assuming >= 32 bits */
+#define ulong Unsigned /* assuming >= 32 bits */
#undef uptr
-#define uptr unsigned long
+#define uptr Unsigned
/* When you say memory, my mind reasons in terms of (pointers to) blocks */
typedef uchar block;
diff --git a/pypy/translator/c/src/rtyper.h b/pypy/translator/c/src/rtyper.h
--- a/pypy/translator/c/src/rtyper.h
+++ b/pypy/translator/c/src/rtyper.h
@@ -30,7 +30,7 @@
char *RPyString_AsCharP(RPyString *rps)
{
- long len = RPyString_Size(rps);
+ Signed len = RPyString_Size(rps);
struct _RPyString_dump_t *dump = \
malloc(sizeof(struct _RPyString_dump_t) + len);
if (!dump)
diff --git a/pypy/translator/c/src/signals.h b/pypy/translator/c/src/signals.h
--- a/pypy/translator/c/src/signals.h
+++ b/pypy/translator/c/src/signals.h
@@ -54,7 +54,7 @@
/* When a signal is received, pypysig_counter is set to -1. */
/* This is a struct for the JIT. See interp_signal.py. */
struct pypysig_long_struct {
- long value;
+ Signed value;
};
extern struct pypysig_long_struct pypysig_counter;
diff --git a/pypy/translator/c/test/test_newgc.py b/pypy/translator/c/test/test_newgc.py
--- a/pypy/translator/c/test/test_newgc.py
+++ b/pypy/translator/c/test/test_newgc.py
@@ -675,8 +675,8 @@
gc.collect()
p_a1 = rffi.cast(rffi.VOIDPP, ll_args[0])[0]
p_a2 = rffi.cast(rffi.VOIDPP, ll_args[1])[0]
- a1 = rffi.cast(rffi.LONGP, p_a1)[0]
- a2 = rffi.cast(rffi.LONGP, p_a2)[0]
+ a1 = rffi.cast(rffi.SIGNEDP, p_a1)[0]
+ a2 = rffi.cast(rffi.SIGNEDP, p_a2)[0]
res = rffi.cast(rffi.INTP, ll_res)
if a1 > a2:
res[0] = rffi.cast(rffi.INT, 1)
@@ -1202,7 +1202,7 @@
def f():
from pypy.rpython.lltypesystem import lltype, rffi
alist = [A() for i in range(50000)]
- idarray = lltype.malloc(rffi.LONGP.TO, len(alist), flavor='raw')
+ idarray = lltype.malloc(rffi.SIGNEDP.TO, len(alist), flavor='raw')
# Compute the id of all elements of the list. The goal is
# to not allocate memory, so that if the GC needs memory to
# remember the ids, it will trigger some collections itself
@@ -1318,6 +1318,23 @@
res = self.run('string_builder_over_allocation')
assert res[1000] == 'y'
+ def definestr_string_builder_multiple_builds(cls):
+ import gc
+ def fn(_):
+ s = StringBuilder(4)
+ got = []
+ for i in range(50):
+ s.append(chr(33+i))
+ got.append(s.build())
+ gc.collect()
+ return ' '.join(got)
+ return fn
+
+ def test_string_builder_multiple_builds(self):
+ res = self.run('string_builder_multiple_builds')
+ assert res == ' '.join([''.join(map(chr, range(33, 33+length)))
+ for length in range(1, 51)])
+
def define_nursery_hash_base(cls):
from pypy.rlib.objectmodel import compute_identity_hash
class A:
diff --git a/pypy/translator/platform/__init__.py b/pypy/translator/platform/__init__.py
--- a/pypy/translator/platform/__init__.py
+++ b/pypy/translator/platform/__init__.py
@@ -59,7 +59,11 @@
compile_args = self._compile_args_from_eci(eci, standalone)
ofiles = []
for cfile in cfiles:
- ofiles.append(self._compile_c_file(self.cc, cfile, compile_args))
+ # Windows hack: use masm for files ending in .asm
+ if str(cfile).lower().endswith('.asm'):
+ ofiles.append(self._compile_c_file(self.masm, cfile, []))
+ else:
+ ofiles.append(self._compile_c_file(self.cc, cfile, compile_args))
return ofiles
def execute(self, executable, args=None, env=None, compilation_info=None):
diff --git a/pypy/translator/platform/windows.py b/pypy/translator/platform/windows.py
--- a/pypy/translator/platform/windows.py
+++ b/pypy/translator/platform/windows.py
@@ -6,12 +6,13 @@
from pypy.translator.platform import CompilationError
from pypy.translator.platform import log, _run_subprocess
from pypy.translator.platform import Platform, posix
+from pypy.rlib.rarithmetic import is_emulated_long
def Windows(cc=None):
if cc == 'mingw32':
return MingwPlatform(cc)
else:
- return MsvcPlatform(cc)
+ return MsvcPlatform(x64=is_emulated_long)
def _get_msvc_env(vsver):
try:
@@ -80,7 +81,8 @@
shared_only = ()
environ = None
- def __init__(self, cc=None):
+ def __init__(self, cc=None, x64='error'):
+ assert x64 <> 'error', "explicit platform definition is mandatory for windows!"
Platform.__init__(self, 'cl.exe')
if msvc_compiler_environ:
self.c_environ = os.environ.copy()
@@ -103,9 +105,16 @@
env=self.c_environ)
r = re.search('Macro Assembler', stderr)
if r is None and os.path.exists('c:/masm32/bin/ml.exe'):
- self.masm = 'c:/masm32/bin/ml.exe'
+ masm32 = 'c:/masm32/bin/ml.exe'
+ masm64 = 'c:/masm64/bin/ml64.exe'
else:
- self.masm = 'ml.exe'
+ masm32 = 'ml.exe'
+ masm64 = 'ml64.exe'
+
+ if x64:
+ self.masm = masm64
+ else:
+ self.masm = masm32
# Install debug options only when interpreter is in debug mode
if sys.executable.lower().endswith('_d.exe'):
@@ -165,7 +174,13 @@
def _compile_c_file(self, cc, cfile, compile_args):
oname = cfile.new(ext='obj')
- args = ['/nologo', '/c'] + compile_args + [str(cfile), '/Fo%s' % (oname,)]
+ # notabene: (tismer)
+ # This function may be called for .c but also .asm files.
+ # The c compiler accepts any order of arguments, while
+ # the assembler still has the old behavior that all options
+ # must come first, and after the file name all options are ignored.
+ # So please be careful with the oder of parameters! ;-)
+ args = ['/nologo', '/c'] + compile_args + ['/Fo%s' % (oname,), str(cfile)]
self._execute_c_compiler(cc, args, oname)
return oname
diff --git a/pypy/translator/simplify.py b/pypy/translator/simplify.py
--- a/pypy/translator/simplify.py
+++ b/pypy/translator/simplify.py
@@ -697,10 +697,12 @@
if op.opname == 'getattr' and op.args[1] == c_append:
vlist = variable_families.find_rep(op.args[0])
if vlist in newlist_v:
- op2 = block.operations[i+1]
- if (op2.opname == 'simple_call' and len(op2.args) == 2
- and op2.args[0] is op.result):
- append_v.append((op.args[0], op.result, block))
+ for j in range(i + 1, len(block.operations)):
+ op2 = block.operations[j]
+ if (op2.opname == 'simple_call' and len(op2.args) == 2
+ and op2.args[0] is op.result):
+ append_v.append((op.args[0], op.result, block))
+ break
if not append_v:
return
detector = ListComprehensionDetector(graph, loops, newlist_v,
diff --git a/pypy/translator/test/test_simplify.py b/pypy/translator/test/test_simplify.py
--- a/pypy/translator/test/test_simplify.py
+++ b/pypy/translator/test/test_simplify.py
@@ -305,6 +305,27 @@
'hint': 2,
})
+ def test_iterate_over_list(self):
+ def wrap(elem):
+ return elem
+
+ def f(i):
+ new_l = []
+ l = range(4)
+ for elem in l:
+ new_l.append(wrap(elem))
+ return new_l
+
+ self.check(f, {
+ 'hint': 2,
+ 'newlist': 1,
+ 'iter': 1,
+ 'next': 1,
+ 'getattr': 1,
+ 'simple_call': 3,
+ })
+
+
class TestLLSpecializeListComprehension:
typesystem = 'lltype'
More information about the pypy-commit
mailing list