[pypy-commit] pypy dynamic-specialized-tuple: merged default in
alex_gaynor
noreply at buildbot.pypy.org
Wed Mar 14 22:02:15 CET 2012
Author: Alex Gaynor <alex.gaynor at gmail.com>
Branch: dynamic-specialized-tuple
Changeset: r53601:82b382cf5d93
Date: 2012-03-14 13:23 -0700
http://bitbucket.org/pypy/pypy/changeset/82b382cf5d93/
Log: merged default in
diff --git a/lib-python/2.7/SimpleXMLRPCServer.py b/lib-python/2.7/SimpleXMLRPCServer.py
--- a/lib-python/2.7/SimpleXMLRPCServer.py
+++ b/lib-python/2.7/SimpleXMLRPCServer.py
@@ -486,7 +486,10 @@
L = []
while size_remaining:
chunk_size = min(size_remaining, max_chunk_size)
- L.append(self.rfile.read(chunk_size))
+ chunk = self.rfile.read(chunk_size)
+ if not chunk:
+ break
+ L.append(chunk)
size_remaining -= len(L[-1])
data = ''.join(L)
diff --git a/lib-python/2.7/test/test_xmlrpc.py b/lib-python/2.7/test/test_xmlrpc.py
--- a/lib-python/2.7/test/test_xmlrpc.py
+++ b/lib-python/2.7/test/test_xmlrpc.py
@@ -308,7 +308,7 @@
global ADDR, PORT, URL
ADDR, PORT = serv.socket.getsockname()
#connect to IP address directly. This avoids socket.create_connection()
- #trying to connect to to "localhost" using all address families, which
+ #trying to connect to "localhost" using all address families, which
#causes slowdown e.g. on vista which supports AF_INET6. The server listens
#on AF_INET only.
URL = "http://%s:%d"%(ADDR, PORT)
@@ -367,7 +367,7 @@
global ADDR, PORT, URL
ADDR, PORT = serv.socket.getsockname()
#connect to IP address directly. This avoids socket.create_connection()
- #trying to connect to to "localhost" using all address families, which
+ #trying to connect to "localhost" using all address families, which
#causes slowdown e.g. on vista which supports AF_INET6. The server listens
#on AF_INET only.
URL = "http://%s:%d"%(ADDR, PORT)
@@ -472,6 +472,9 @@
# protocol error; provide additional information in test output
self.fail("%s\n%s" % (e, getattr(e, "headers", "")))
+ def test_unicode_host(self):
+ server = xmlrpclib.ServerProxy(u"http://%s:%d/RPC2"%(ADDR, PORT))
+ self.assertEqual(server.add("a", u"\xe9"), u"a\xe9")
# [ch] The test 404 is causing lots of false alarms.
def XXXtest_404(self):
@@ -586,6 +589,12 @@
# This avoids waiting for the socket timeout.
self.test_simple1()
+ def test_partial_post(self):
+ # Check that a partial POST doesn't make the server loop: issue #14001.
+ conn = httplib.HTTPConnection(ADDR, PORT)
+ conn.request('POST', '/RPC2 HTTP/1.0\r\nContent-Length: 100\r\n\r\nbye')
+ conn.close()
+
class MultiPathServerTestCase(BaseServerTestCase):
threadFunc = staticmethod(http_multi_server)
request_count = 2
diff --git a/lib-python/modified-2.7/distutils/sysconfig_pypy.py b/lib-python/modified-2.7/distutils/sysconfig_pypy.py
--- a/lib-python/modified-2.7/distutils/sysconfig_pypy.py
+++ b/lib-python/modified-2.7/distutils/sysconfig_pypy.py
@@ -60,6 +60,7 @@
g['EXE'] = ""
g['SO'] = _get_so_extension() or ".so"
g['SOABI'] = g['SO'].rsplit('.')[0]
+ g['LIBDIR'] = os.path.join(sys.prefix, 'lib')
global _config_vars
_config_vars = g
diff --git a/pypy/annotation/builtin.py b/pypy/annotation/builtin.py
--- a/pypy/annotation/builtin.py
+++ b/pypy/annotation/builtin.py
@@ -167,7 +167,7 @@
r.const = False
return r
- assert not issubclass(typ, (int,long)) or typ in (bool, int), (
+ assert not issubclass(typ, (int, long)) or typ in (bool, int, long), (
"for integers only isinstance(.,int|r_uint) are supported")
if s_obj.is_constant():
diff --git a/pypy/jit/backend/llsupport/gc.py b/pypy/jit/backend/llsupport/gc.py
--- a/pypy/jit/backend/llsupport/gc.py
+++ b/pypy/jit/backend/llsupport/gc.py
@@ -599,7 +599,7 @@
# if convenient for the backend, we compute the info about
# the flag as (byte-offset, single-byte-flag).
import struct
- value = struct.pack("l", flag_word)
+ value = struct.pack(lltype.SignedFmt, flag_word)
assert value.count('\x00') == len(value) - 1 # only one byte is != 0
i = 0
while value[i] == '\x00': i += 1
diff --git a/pypy/jit/backend/llsupport/test/test_descr.py b/pypy/jit/backend/llsupport/test/test_descr.py
--- a/pypy/jit/backend/llsupport/test/test_descr.py
+++ b/pypy/jit/backend/llsupport/test/test_descr.py
@@ -148,7 +148,7 @@
#
def get_alignment(code):
# Retrieve default alignment for the compiler/platform
- return struct.calcsize('l' + code) - struct.calcsize(code)
+ return struct.calcsize(lltype.SignedFmt + code) - struct.calcsize(code)
assert descr1.basesize == get_alignment('c')
assert descr2.basesize == get_alignment('p')
assert descr3.basesize == get_alignment('p')
diff --git a/pypy/jit/backend/llsupport/test/test_ffisupport.py b/pypy/jit/backend/llsupport/test/test_ffisupport.py
--- a/pypy/jit/backend/llsupport/test/test_ffisupport.py
+++ b/pypy/jit/backend/llsupport/test/test_ffisupport.py
@@ -2,6 +2,7 @@
from pypy.jit.codewriter.longlong import is_64_bit
from pypy.jit.backend.llsupport.descr import *
from pypy.jit.backend.llsupport.ffisupport import *
+from pypy.rlib.rarithmetic import is_emulated_long
class FakeCPU:
@@ -43,7 +44,7 @@
assert descr.result_flag == FLAG_UNSIGNED
assert descr.is_result_signed() == False
- if not is_64_bit:
+ if not is_64_bit or is_emulated_long:
descr = get_call_descr_dynamic(FakeCPU(), [], types.slonglong,
None, 42)
assert descr is None # missing longlongs
diff --git a/pypy/jit/backend/test/runner_test.py b/pypy/jit/backend/test/runner_test.py
--- a/pypy/jit/backend/test/runner_test.py
+++ b/pypy/jit/backend/test/runner_test.py
@@ -16,7 +16,7 @@
from pypy.rpython.annlowlevel import llhelper
from pypy.rpython.llinterp import LLException
from pypy.jit.codewriter import heaptracker, longlong
-from pypy.rlib.rarithmetic import intmask
+from pypy.rlib.rarithmetic import intmask, is_valid_int
from pypy.jit.backend.detect_cpu import autodetect_main_model_and_size
def boxfloat(x):
@@ -493,7 +493,7 @@
if cpu.supports_floats:
def func(f, i):
assert isinstance(f, float)
- assert isinstance(i, int)
+ assert is_valid_int(i)
return f - float(i)
FPTR = self.Ptr(self.FuncType([lltype.Float, lltype.Signed],
lltype.Float))
diff --git a/pypy/jit/backend/x86/test/conftest.py b/pypy/jit/backend/x86/test/conftest.py
--- a/pypy/jit/backend/x86/test/conftest.py
+++ b/pypy/jit/backend/x86/test/conftest.py
@@ -1,4 +1,4 @@
-import py
+import py, os
from pypy.jit.backend import detect_cpu
cpu = detect_cpu.autodetect()
@@ -6,5 +6,7 @@
if cpu not in ('x86', 'x86_64'):
py.test.skip("x86/x86_64 tests skipped: cpu is %r" % (cpu,))
if cpu == 'x86_64':
+ if os.name == "nt":
+ py.test.skip("Windows cannot allocate non-reserved memory")
from pypy.rpython.lltypesystem import ll2ctypes
ll2ctypes.do_allocation_in_far_regions()
diff --git a/pypy/jit/backend/x86/tool/viewcode.py b/pypy/jit/backend/x86/tool/viewcode.py
--- a/pypy/jit/backend/x86/tool/viewcode.py
+++ b/pypy/jit/backend/x86/tool/viewcode.py
@@ -34,7 +34,7 @@
# I am porting it in a lazy fashion... See py-utils/xam.py
if sys.platform == "win32":
- XXX # lots more in Psyco
+ pass # lots more in Psyco
def machine_code_dump(data, originaddr, backend_name, label_list=None):
objdump_backend_option = {
diff --git a/pypy/jit/codewriter/test/test_longlong.py b/pypy/jit/codewriter/test/test_longlong.py
--- a/pypy/jit/codewriter/test/test_longlong.py
+++ b/pypy/jit/codewriter/test/test_longlong.py
@@ -1,6 +1,6 @@
import py, sys
-from pypy.rlib.rarithmetic import r_longlong, intmask
+from pypy.rlib.rarithmetic import r_longlong, intmask, is_valid_int
from pypy.objspace.flow.model import SpaceOperation, Variable, Constant
from pypy.objspace.flow.model import Block, Link
from pypy.translator.unsimplify import varoftype
@@ -32,7 +32,7 @@
def test_functions():
xll = longlong.getfloatstorage(3.5)
assert longlong.getrealfloat(xll) == 3.5
- assert isinstance(longlong.gethash(xll), int)
+ assert is_valid_int(longlong.gethash(xll))
class TestLongLong:
diff --git a/pypy/jit/metainterp/blackhole.py b/pypy/jit/metainterp/blackhole.py
--- a/pypy/jit/metainterp/blackhole.py
+++ b/pypy/jit/metainterp/blackhole.py
@@ -1185,14 +1185,14 @@
def bhimpl_getinteriorfield_gc_f(cpu, array, index, descr):
return cpu.bh_getinteriorfield_gc_f(array, index, descr)
- @arguments("cpu", "r", "i", "d", "i")
- def bhimpl_setinteriorfield_gc_i(cpu, array, index, descr, value):
+ @arguments("cpu", "r", "i", "i", "d")
+ def bhimpl_setinteriorfield_gc_i(cpu, array, index, value, descr):
cpu.bh_setinteriorfield_gc_i(array, index, descr, value)
- @arguments("cpu", "r", "i", "d", "r")
- def bhimpl_setinteriorfield_gc_r(cpu, array, index, descr, value):
+ @arguments("cpu", "r", "i", "r", "d")
+ def bhimpl_setinteriorfield_gc_r(cpu, array, index, value, descr):
cpu.bh_setinteriorfield_gc_r(array, index, descr, value)
- @arguments("cpu", "r", "i", "d", "f")
- def bhimpl_setinteriorfield_gc_f(cpu, array, index, descr, value):
+ @arguments("cpu", "r", "i", "f", "d")
+ def bhimpl_setinteriorfield_gc_f(cpu, array, index, value, descr):
cpu.bh_setinteriorfield_gc_f(array, index, descr, value)
@arguments("cpu", "r", "d", returns="i")
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
@@ -2,7 +2,7 @@
"""
from pypy.rpython.lltypesystem import lltype, rstr
-from pypy.rlib.rarithmetic import ovfcheck, r_longlong
+from pypy.rlib.rarithmetic import ovfcheck, r_longlong, is_valid_int
from pypy.rlib.rtimer import read_timestamp
from pypy.rlib.unroll import unrolling_iterable
from pypy.jit.metainterp.history import BoxInt, BoxPtr, BoxFloat, check_descr
@@ -248,7 +248,7 @@
def do_read_timestamp(cpu, _):
x = read_timestamp()
if longlong.is_64_bit:
- assert isinstance(x, int) # 64-bit
+ assert is_valid_int(x) # 64-bit
return BoxInt(x)
else:
assert isinstance(x, r_longlong) # 32-bit
diff --git a/pypy/jit/metainterp/history.py b/pypy/jit/metainterp/history.py
--- a/pypy/jit/metainterp/history.py
+++ b/pypy/jit/metainterp/history.py
@@ -4,7 +4,8 @@
from pypy.rpython.ootypesystem import ootype
from pypy.rlib.objectmodel import we_are_translated, Symbolic
from pypy.rlib.objectmodel import compute_unique_id
-from pypy.rlib.rarithmetic import r_int64
+from pypy.rlib.rarithmetic import r_int64, is_valid_int
+
from pypy.conftest import option
from pypy.jit.metainterp.resoperation import ResOperation, rop
@@ -213,7 +214,7 @@
def __init__(self, value):
if not we_are_translated():
- if isinstance(value, int):
+ if is_valid_int(value):
value = int(value) # bool -> int
else:
assert isinstance(value, Symbolic)
@@ -448,7 +449,7 @@
def __init__(self, value=0):
if not we_are_translated():
- if isinstance(value, int):
+ if is_valid_int(value):
value = int(value) # bool -> int
else:
assert isinstance(value, Symbolic)
diff --git a/pypy/jit/metainterp/optimizeopt/intutils.py b/pypy/jit/metainterp/optimizeopt/intutils.py
--- a/pypy/jit/metainterp/optimizeopt/intutils.py
+++ b/pypy/jit/metainterp/optimizeopt/intutils.py
@@ -1,10 +1,9 @@
-from pypy.rlib.rarithmetic import ovfcheck, LONG_BIT
+from pypy.rlib.rarithmetic import ovfcheck, LONG_BIT, maxint, is_valid_int
from pypy.rlib.objectmodel import we_are_translated
from pypy.jit.metainterp.resoperation import rop, ResOperation
from pypy.jit.metainterp.history import BoxInt, ConstInt
-import sys
-MAXINT = sys.maxint
-MININT = -sys.maxint - 1
+MAXINT = maxint
+MININT = -maxint - 1
class IntBound(object):
_attrs_ = ('has_upper', 'has_lower', 'upper', 'lower')
@@ -16,8 +15,8 @@
self.lower = lower
# check for unexpected overflows:
if not we_are_translated():
- assert type(upper) is not long
- assert type(lower) is not long
+ assert type(upper) is not long or is_valid_int(upper)
+ assert type(lower) is not long or is_valid_int(lower)
# Returns True if the bound was updated
def make_le(self, other):
diff --git a/pypy/jit/metainterp/optimizeopt/vstring.py b/pypy/jit/metainterp/optimizeopt/vstring.py
--- a/pypy/jit/metainterp/optimizeopt/vstring.py
+++ b/pypy/jit/metainterp/optimizeopt/vstring.py
@@ -10,6 +10,8 @@
from pypy.rlib.unroll import unrolling_iterable
from pypy.rpython import annlowlevel
from pypy.rpython.lltypesystem import lltype, rstr
+from pypy.rlib.rarithmetic import is_valid_int
+
class StrOrUnicode(object):
@@ -730,7 +732,7 @@
for name in dir(OptString):
if name.startswith(prefix):
value = getattr(EffectInfo, 'OS_' + name[len(prefix):])
- assert isinstance(value, int) and value != 0
+ assert is_valid_int(value) and value != 0
result.append((value, getattr(OptString, name)))
return unrolling_iterable(result)
opt_call_oopspec_ops = _findall_call_oopspec()
diff --git a/pypy/jit/metainterp/test/test_ajit.py b/pypy/jit/metainterp/test/test_ajit.py
--- a/pypy/jit/metainterp/test/test_ajit.py
+++ b/pypy/jit/metainterp/test/test_ajit.py
@@ -14,7 +14,7 @@
loop_invariant, elidable, promote, jit_debug, assert_green,
AssertGreenFailed, unroll_safe, current_trace_length, look_inside_iff,
isconstant, isvirtual, promote_string, set_param, record_known_class)
-from pypy.rlib.rarithmetic import ovfcheck
+from pypy.rlib.rarithmetic import ovfcheck, is_valid_int
from pypy.rpython.lltypesystem import lltype, llmemory, rffi
from pypy.rpython.ootypesystem import ootype
@@ -2296,7 +2296,7 @@
self.check_resops(int_rshift=3)
bigval = 1
- while (bigval << 3).__class__ is int:
+ while is_valid_int(bigval << 3):
bigval = bigval << 1
assert self.meta_interp(f, [bigval, 5]) == 0
@@ -2341,7 +2341,7 @@
self.check_resops(int_rshift=3)
bigval = 1
- while (bigval << 3).__class__ is int:
+ while is_valid_int(bigval << 3):
bigval = bigval << 1
assert self.meta_interp(f, [bigval, 5]) == 0
@@ -3784,6 +3784,15 @@
assert res == 11 * 12 * 13
self.check_operations_history(int_add=3, int_mul=2)
+ def test_setinteriorfield(self):
+ A = lltype.GcArray(lltype.Struct('S', ('x', lltype.Signed)))
+ a = lltype.malloc(A, 5, immortal=True)
+ def g(n):
+ a[n].x = n + 2
+ return a[n].x
+ res = self.interp_operations(g, [1])
+ assert res == 3
+
class TestLLtype(BaseLLtypeTests, LLJitMixin):
def test_tagged(self):
diff --git a/pypy/module/_multiprocessing/test/test_semaphore.py b/pypy/module/_multiprocessing/test/test_semaphore.py
--- a/pypy/module/_multiprocessing/test/test_semaphore.py
+++ b/pypy/module/_multiprocessing/test/test_semaphore.py
@@ -1,6 +1,8 @@
from pypy.conftest import gettestobjspace
from pypy.module._multiprocessing.interp_semaphore import (
RECURSIVE_MUTEX, SEMAPHORE)
+from pypy.rlib.rarithmetic import is_valid_int
+
class AppTestSemaphore:
def setup_class(cls):
@@ -20,7 +22,7 @@
sem = SemLock(kind, value, maxvalue)
assert sem.kind == kind
assert sem.maxvalue == maxvalue
- assert isinstance(sem.handle, (int, long))
+ assert is_valid_int(sem.handle)
assert sem._count() == 0
if sys.platform == 'darwin':
diff --git a/pypy/module/_ssl/test/test_ssl.py b/pypy/module/_ssl/test/test_ssl.py
--- a/pypy/module/_ssl/test/test_ssl.py
+++ b/pypy/module/_ssl/test/test_ssl.py
@@ -1,6 +1,8 @@
from pypy.conftest import gettestobjspace
import os
import py
+from pypy.rlib.rarithmetic import is_valid_int
+
class AppTestSSL:
def setup_class(cls):
@@ -29,7 +31,7 @@
assert isinstance(_ssl.SSL_ERROR_EOF, int)
assert isinstance(_ssl.SSL_ERROR_INVALID_ERROR_CODE, int)
- assert isinstance(_ssl.OPENSSL_VERSION_NUMBER, (int, long))
+ assert is_valid_int(_ssl.OPENSSL_VERSION_NUMBER)
assert isinstance(_ssl.OPENSSL_VERSION_INFO, tuple)
assert len(_ssl.OPENSSL_VERSION_INFO) == 5
assert isinstance(_ssl.OPENSSL_VERSION, str)
diff --git a/pypy/module/marshal/interp_marshal.py b/pypy/module/marshal/interp_marshal.py
--- a/pypy/module/marshal/interp_marshal.py
+++ b/pypy/module/marshal/interp_marshal.py
@@ -327,8 +327,10 @@
# %r not supported in rpython
#u.raise_exc('invalid typecode in unmarshal: %r' % tc)
c = ord(tc)
- if c < 32 or c > 126:
- s = '\\x' + hex(c)
+ if c < 16:
+ s = '\\x0%x' % c
+ elif c < 32 or c > 126:
+ s = '\\x%x' % c
elif tc == '\\':
s = r'\\'
else:
diff --git a/pypy/module/marshal/test/test_marshal.py b/pypy/module/marshal/test/test_marshal.py
--- a/pypy/module/marshal/test/test_marshal.py
+++ b/pypy/module/marshal/test/test_marshal.py
@@ -174,6 +174,11 @@
pass
raises(ValueError, marshal.dumps, subtype)
+ def test_bad_typecode(self):
+ import marshal
+ exc = raises(ValueError, marshal.loads, chr(1))
+ assert r"'\x01'" in exc.value.message
+
class AppTestRope(AppTestMarshal):
def setup_class(cls):
diff --git a/pypy/module/math/test/test_direct.py b/pypy/module/math/test/test_direct.py
--- a/pypy/module/math/test/test_direct.py
+++ b/pypy/module/math/test/test_direct.py
@@ -55,6 +55,12 @@
('frexp', (-1.25,), lambda x: x == (-0.625, 1)),
('modf', (4.25,), lambda x: x == (0.25, 4.0)),
('modf', (-4.25,), lambda x: x == (-0.25, -4.0)),
+ ('copysign', (1.5, 0.0), 1.5),
+ ('copysign', (1.5, -0.0), -1.5),
+ ('copysign', (1.5, INFINITY), 1.5),
+ ('copysign', (1.5, -INFINITY), -1.5),
+ ('copysign', (1.5, NAN), 1.5),
+ ('copysign', (1.75, -NAN), -1.75), # special case for -NAN here
]
OVFCASES = [
diff --git a/pypy/module/math/test/test_math.py b/pypy/module/math/test/test_math.py
--- a/pypy/module/math/test/test_math.py
+++ b/pypy/module/math/test/test_math.py
@@ -1,3 +1,4 @@
+from __future__ import with_statement
import sys
from pypy.conftest import gettestobjspace
from pypy.module.math.test import test_direct
@@ -268,3 +269,7 @@
def __trunc__(self):
return "truncated"
assert math.trunc(foo()) == "truncated"
+
+ def test_copysign_nan(self):
+ import math
+ assert math.copysign(1.0, float('-nan')) == -1.0
diff --git a/pypy/module/mmap/__init__.py b/pypy/module/mmap/__init__.py
--- a/pypy/module/mmap/__init__.py
+++ b/pypy/module/mmap/__init__.py
@@ -18,7 +18,7 @@
def buildloaders(cls):
from pypy.module.mmap import interp_mmap
for constant, value in rmmap.constants.iteritems():
- if isinstance(value, int):
+ if isinstance(value, (int, long)):
Module.interpleveldefs[constant] = "space.wrap(%r)" % value
super(Module, cls).buildloaders()
diff --git a/pypy/module/signal/interp_signal.py b/pypy/module/signal/interp_signal.py
--- a/pypy/module/signal/interp_signal.py
+++ b/pypy/module/signal/interp_signal.py
@@ -11,11 +11,11 @@
import sys
from pypy.tool import autopath
from pypy.rlib import jit, rposix
-from pypy.rlib.rarithmetic import intmask
+from pypy.rlib.rarithmetic import intmask, is_valid_int
def setup():
for key, value in cpy_signal.__dict__.items():
- if key.startswith('SIG') and isinstance(value, int):
+ if key.startswith('SIG') and is_valid_int(value):
globals()[key] = value
yield key
diff --git a/pypy/objspace/flow/model.py b/pypy/objspace/flow/model.py
--- a/pypy/objspace/flow/model.py
+++ b/pypy/objspace/flow/model.py
@@ -8,6 +8,8 @@
from pypy.tool.descriptor import roproperty
from pypy.tool.sourcetools import PY_IDENTIFIER, nice_repr_for_func
from pypy.tool.identity_dict import identity_dict
+from pypy.rlib.rarithmetic import is_valid_int
+
"""
memory size before and after introduction of __slots__
@@ -542,7 +544,7 @@
cases = [link.exitcase for link in block.exits]
has_default = cases[-1] == 'default'
for n in cases[:len(cases)-has_default]:
- if isinstance(n, (int, long)):
+ if is_valid_int(n):
continue
if isinstance(n, (str, unicode)) and len(n) == 1:
continue
diff --git a/pypy/objspace/flow/objspace.py b/pypy/objspace/flow/objspace.py
--- a/pypy/objspace/flow/objspace.py
+++ b/pypy/objspace/flow/objspace.py
@@ -14,6 +14,7 @@
from pypy.objspace.flow import flowcontext, operation, specialcase
from pypy.rlib.unroll import unrolling_iterable, _unroller
from pypy.rlib import rstackovf, rarithmetic
+from pypy.rlib.rarithmetic import is_valid_int
# method-wrappers have not enough introspection in CPython
@@ -141,7 +142,7 @@
def int_w(self, w_obj):
if isinstance(w_obj, Constant):
val = w_obj.value
- if type(val) not in (int,long):
+ if not is_valid_int(val):
raise TypeError("expected integer: " + repr(w_obj))
return val
return self.unwrap(w_obj)
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, maxint
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib import jit
@@ -165,6 +165,10 @@
return self.newbool(x)
else:
return self.newint(x)
+ # this is an inlined 'is_valid_int' which cannot be used
+ # due to the special annotation nature of 'wrap'.
+ if isinstance(x, long) and (-maxint - 1 <= x <= maxint):
+ return self.newint(x)
if isinstance(x, str):
return wrapstr(self, x)
if isinstance(x, unicode):
diff --git a/pypy/objspace/std/strutil.py b/pypy/objspace/std/strutil.py
--- a/pypy/objspace/std/strutil.py
+++ b/pypy/objspace/std/strutil.py
@@ -177,8 +177,10 @@
return INFINITY
elif low == "infinity" or low == "+infinity":
return INFINITY
- elif low == "nan" or low == "-nan" or low == "+nan":
+ elif low == "nan" or low == "+nan":
return NAN
+ elif low == "-nan":
+ return -NAN
try:
return rstring_to_float(s)
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,6 +3,7 @@
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
@@ -14,7 +15,11 @@
separate_module_sources = ['#include "src/stacklet/stacklet.c"\n'],
)
if sys.platform == 'win32':
- eci.separate_module_files += (cdir / "src/stacklet/switch_x86_msvc.asm", )
+ 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',
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"
@@ -119,6 +120,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'],
@@ -126,7 +131,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',
@@ -142,7 +147,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')
@@ -312,7 +317,7 @@
FFI_OK = cConfig.FFI_OK
FFI_BAD_TYPEDEF = cConfig.FFI_BAD_TYPEDEF
FFI_DEFAULT_ABI = cConfig.FFI_DEFAULT_ABI
-if _WIN32:
+if _WIN32 and not _WIN64:
FFI_STDCALL = cConfig.FFI_STDCALL
FFI_TYPE_STRUCT = cConfig.FFI_TYPE_STRUCT
FFI_CIFP = rffi.COpaquePtr('ffi_cif', compilation_info=eci)
@@ -458,7 +463,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
@@ -1,5 +1,7 @@
import sys, time
from pypy.rpython.extregistry import ExtRegistryEntry
+from pypy.rlib.rarithmetic import is_valid_int
+
def ll_assert(x, msg):
"""After translation to C, this becomes an RPyAssert."""
@@ -335,7 +337,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 is_valid_int(x)
return x
class Entry(ExtRegistryEntry):
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,12 +87,18 @@
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:
@@ -95,7 +133,12 @@
r_class.BITS == LONG_BIT and r_class.SIGNED)
_should_widen_type._annspecialcase_ = 'specialize:memo'
-del _bits, _itest, _Ltest
+# the replacement for sys.maxint
+maxint = int(LONG_TEST - 1)
+
+def is_valid_int(r):
+ return isinstance(r, (int, long)) and (
+ -maxint - 1 <= r <= maxint)
def ovfcheck(r):
"NOT_RPYTHON"
@@ -103,8 +146,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):
+ # checks only if applicable to r's type.
+ # this happens in the garbage collector.
raise OverflowError, "signed integer expression did overflow"
return r
@@ -418,6 +463,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:
@@ -425,6 +473,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 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 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
@@ -24,11 +24,11 @@
from pypy.rpython.lltypesystem.rclass import OBJECTPTR
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython.error import TyperError
-
+from pypy.rlib.rarithmetic import is_valid_int
def erase_int(x):
- assert isinstance(x, int)
+ assert is_valid_int(x)
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 is_valid_int(y._x)
return y._x
diff --git a/pypy/rlib/rfloat.py b/pypy/rlib/rfloat.py
--- a/pypy/rlib/rfloat.py
+++ b/pypy/rlib/rfloat.py
@@ -295,7 +295,7 @@
return z
INFINITY = 1e200 * 1e200
-NAN = INFINITY / INFINITY
+NAN = abs(INFINITY / INFINITY) # bah, INF/INF gives us -NAN?
try:
# Try to get math functions added in 2.6.
diff --git a/pypy/rlib/rwin32.py b/pypy/rlib/rwin32.py
--- a/pypy/rlib/rwin32.py
+++ b/pypy/rlib/rwin32.py
@@ -133,8 +133,8 @@
# Prior to Visual Studio 8, the MSVCRT dll doesn't export the
# _dosmaperr() function, which is available only when compiled
# against the static CRT library.
- from pypy.translator.platform import platform, Windows
- static_platform = Windows()
+ from pypy.translator.platform import host_factory
+ static_platform = host_factory()
if static_platform.name == 'msvc':
static_platform.cflags = ['/MT'] # static CRT
static_platform.version = 0 # no manifest
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
@@ -14,12 +14,14 @@
else:
load_library_kwargs = {}
-import os
+import os, platform as host_platform
+from pypy import conftest
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython.extfunc import ExtRegistryEntry
from pypy.rlib.objectmodel import Symbolic, ComputedIntSymbolic
from pypy.tool.uid import fixid
from pypy.rlib.rarithmetic import r_singlefloat, r_longfloat, base_int, intmask
+from pypy.rlib.rarithmetic import is_emulated_long, maxint
from pypy.annotation import model as annmodel
from pypy.rpython.llinterp import LLInterpreter, LLException
from pypy.rpython.lltypesystem.rclass import OBJECT, OBJECT_VTABLE
@@ -32,6 +34,12 @@
class tlsobject(object):
pass
+_POSIX = os.name == "posix"
+_MS_WINDOWS = os.name == "nt"
+_LINUX = "linux" in sys.platform
+_64BIT = "64bit" in host_platform.architecture()[0]
+
+
# ____________________________________________________________
far_regions = None
@@ -68,17 +76,22 @@
global far_regions
if not far_regions:
from pypy.rlib import rmmap
- if sys.maxint > 0x7FFFFFFF:
+ if _64BIT:
PIECESIZE = 0x80000000
else:
- if sys.platform == 'linux':
+ if _LINUX:
PIECESIZE = 0x10000000
else:
PIECESIZE = 0x08000000
PIECES = 10
- m = rmmap.mmap(-1, PIECES * PIECESIZE,
- rmmap.MAP_PRIVATE|rmmap.MAP_ANONYMOUS|rmmap.MAP_NORESERVE,
- rmmap.PROT_READ|rmmap.PROT_WRITE)
+ flags = 0
+ if _LINUX:
+ flags = (rmmap.MAP_PRIVATE|rmmap.MAP_ANONYMOUS|rmmap.MAP_NORESERVE,
+ rmmap.PROT_READ|rmmap.PROT_WRITE)
+ if _MS_WINDOWS:
+ flags = rmmap.MEM_RESERVE
+ # XXX seems not to work
+ m = rmmap.mmap(-1, PIECES * PIECESIZE, flags)
m.close = lambda : None # leak instead of giving a spurious
# error at CPython's shutdown
m._ll2ctypes_pieces = []
@@ -93,9 +106,17 @@
def _setup_ctypes_cache():
from pypy.rpython.lltypesystem import rffi
+
+ if is_emulated_long:
+ signed_as_ctype = ctypes.c_longlong
+ unsigned_as_ctypes = ctypes.c_ulonglong
+ else:
+ signed_as_ctype = ctypes.c_long
+ unsigned_as_ctypes = ctypes.c_ulong
+
_ctypes_cache.update({
- lltype.Signed: ctypes.c_long,
- lltype.Unsigned: ctypes.c_ulong,
+ lltype.Signed: signed_as_ctype,
+ lltype.Unsigned: unsigned_as_ctypes,
lltype.Char: ctypes.c_ubyte,
rffi.DOUBLE: ctypes.c_double,
rffi.FLOAT: ctypes.c_float,
@@ -176,10 +197,26 @@
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 [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 is_emulated_long:
+ lentype = ctypes.c_longlong
+ else:
+ lentype = ctypes.c_long
+
if not A._hints.get('nolength'):
- _fields_ = [('length', ctypes.c_long),
+ _fields_ = [('length', lentype),
('items', max_n * ctypes_item)]
else:
_fields_ = [('items', max_n * ctypes_item)]
@@ -201,11 +238,16 @@
if cls._ptrtype:
return cls._ptrtype
# ctypes can raise OverflowError on 64-bit builds
- for n in [sys.maxint, 2**31]:
+ # on windows it raises AttributeError even for 2**31 (_length_ missing)
+ if _MS_WINDOWS:
+ other_limit = 2**31-1
+ else:
+ other_limit = 2**31
+ for n in [maxint, other_limit]:
cls.MAX_SIZE = n / ctypes.sizeof(ctypes_item)
try:
cls._ptrtype = ctypes.POINTER(cls.MAX_SIZE * ctypes_item)
- except OverflowError, e:
+ except (OverflowError, AttributeError), e:
pass
else:
break
@@ -566,7 +608,7 @@
def getbounds(self):
# we have no clue, so we allow whatever index
- return 0, sys.maxint
+ return 0, maxint
def getitem(self, index, uninitialized_ok=False):
res = self._storage.contents._getitem(index, boundscheck=False)
@@ -1326,8 +1368,8 @@
res = force_cast(lltype.Signed, addr.ptr)
else:
res = addr._cast_to_int()
- if res > sys.maxint:
- res = res - 2*(sys.maxint + 1)
+ if res > maxint:
+ res = res - 2*(maxint + 1)
assert int(res) == res
return int(res)
return res
diff --git a/pypy/rpython/lltypesystem/llarena.py b/pypy/rpython/lltypesystem/llarena.py
--- a/pypy/rpython/lltypesystem/llarena.py
+++ b/pypy/rpython/lltypesystem/llarena.py
@@ -1,5 +1,7 @@
import array, weakref
from pypy.rpython.lltypesystem import llmemory
+from pypy.rlib.rarithmetic import is_valid_int
+
# An "arena" is a large area of memory which can hold a number of
# objects, not necessarily all of the same type or size. It's used by
@@ -164,7 +166,7 @@
return '<arenaaddr %s + %d>' % (self.arena, self.offset)
def __add__(self, other):
- if isinstance(other, (int, long)):
+ if is_valid_int(other):
position = self.offset + other
elif isinstance(other, llmemory.AddressOffset):
# this is really some Do What I Mean logic. There are two
@@ -184,7 +186,7 @@
def __sub__(self, other):
if isinstance(other, llmemory.AddressOffset):
other = llmemory.raw_malloc_usage(other)
- if isinstance(other, (int, long)):
+ if is_valid_int(other):
return self.arena.getaddr(self.offset - other)
if isinstance(other, fakearenaaddress):
if self.arena is not other.arena:
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
@@ -7,7 +7,7 @@
from pypy.tool.identity_dict import identity_dict
from pypy.tool import leakfinder
from types import NoneType
-from sys import maxint
+from pypy.rlib.rarithmetic import maxint, is_valid_int, is_emulated_long
import weakref
class State(object):
@@ -681,6 +681,11 @@
number = _numbertypes[type] = Number(name, type)
return number
+if is_emulated_long:
+ SignedFmt = 'q'
+else:
+ SignedFmt = 'l'
+
Signed = build_number("Signed", int)
Unsigned = build_number("Unsigned", r_uint)
SignedLongLong = build_number("SignedLongLong", r_longlong)
@@ -1654,7 +1659,7 @@
__slots__ = ('items',)
def __init__(self, TYPE, n, initialization=None, parent=None, parentindex=None):
- if not isinstance(n, int):
+ if not is_valid_int(n):
raise TypeError, "array length must be an int"
if n < 0:
raise ValueError, "negative array length"
diff --git a/pypy/rpython/lltypesystem/module/ll_math.py b/pypy/rpython/lltypesystem/module/ll_math.py
--- a/pypy/rpython/lltypesystem/module/ll_math.py
+++ b/pypy/rpython/lltypesystem/module/ll_math.py
@@ -114,10 +114,8 @@
while VERY_LARGE_FLOAT * 100.0 != INFINITY:
VERY_LARGE_FLOAT *= 64.0
-_lib_isnan = rffi.llexternal("_isnan", [lltype.Float], lltype.Signed,
- compilation_info=eci)
-_lib_finite = rffi.llexternal("_finite", [lltype.Float], lltype.Signed,
- compilation_info=eci)
+_lib_isnan = llexternal("_isnan", [lltype.Float], lltype.Signed)
+_lib_finite = llexternal("_finite", [lltype.Float], lltype.Signed)
def ll_math_isnan(y):
# By not calling into the external function the JIT can inline this.
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
@@ -4,6 +4,8 @@
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython.lltypesystem.lloperation import opimpls
from pypy.rlib import debug
+from pypy.rlib.rarithmetic import is_valid_int
+
# ____________________________________________________________
# Implementation of the 'canfold' operations
@@ -22,14 +24,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 +175,7 @@
def op_direct_ptradd(obj, index):
checkptr(obj)
- assert isinstance(index, int)
+ assert is_valid_int(index)
return lltype.direct_ptradd(obj, index)
@@ -182,29 +184,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 is_valid_int(x):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, int)
+ assert is_valid_int(y)
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 is_valid_int(y)
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 is_valid_int(y)
return x < y
def op_int_between(a, b, c):
@@ -214,50 +217,51 @@
return a <= b < c
def op_int_and(x, y):
- if not isinstance(x, int):
+ if not is_valid_int(x):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, int)
+ assert is_valid_int(y)
return x & y
def op_int_or(x, y):
- if not isinstance(x, int):
+ if not is_valid_int(x):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, int)
+ assert is_valid_int(y)
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 is_valid_int(x)
+ assert is_valid_int(y)
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 is_valid_int(x):
from pypy.rpython.lltypesystem import llgroup
assert isinstance(x, llgroup.CombinedSymbolic)
- assert isinstance(y, int)
+ assert is_valid_int(y)
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 +285,22 @@
def op_uint_lshift(x, y):
assert isinstance(x, r_uint)
- assert isinstance(y, int)
+ assert is_valid_int(y)
return r_uint(x << y)
def op_uint_rshift(x, y):
assert isinstance(x, r_uint)
- assert isinstance(y, int)
+ assert is_valid_int(y)
return r_uint(x >> y)
def op_llong_lshift(x, y):
assert isinstance(x, r_longlong_arg)
- assert isinstance(y, int)
+ assert is_valid_int(y)
return r_longlong_result(x << y)
def op_llong_rshift(x, y):
assert isinstance(x, r_longlong_arg)
- assert isinstance(y, int)
+ assert is_valid_int(y)
return r_longlong_result(x >> y)
def op_ullong_lshift(x, y):
@@ -306,7 +310,7 @@
def op_ullong_rshift(x, y):
assert isinstance(x, r_ulonglong)
- assert isinstance(y, int)
+ assert is_valid_int(y)
return r_ulonglong(x >> y)
def op_same_as(x):
@@ -318,7 +322,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 is_valid_int(i)
return float(i)
def op_cast_uint_to_float(u):
@@ -340,7 +345,8 @@
return ui + li
def op_cast_int_to_char(b):
- assert type(b) is int
+ #assert type(b) is int
+ assert is_valid_int(b)
return chr(b)
def op_cast_bool_to_int(b):
@@ -384,11 +390,12 @@
return ord(b)
def op_cast_int_to_unichar(b):
- assert type(b) is int
+ assert is_valid_int(b)
return unichr(b)
def op_cast_int_to_uint(b):
- assert type(b) is int
+ # assert type(b) is int
+ assert is_valid_int(b)
return r_uint(b)
def op_cast_uint_to_int(b):
@@ -396,7 +403,7 @@
return intmask(b)
def op_cast_int_to_longlong(b):
- assert type(b) is int
+ assert is_valid_int(b)
return r_longlong_result(b)
def op_truncate_longlong_to_int(b):
@@ -570,7 +577,7 @@
if isinstance(memberoffset, llgroup.GroupMemberOffset):
return memberoffset.index != 0
else:
- assert isinstance(memberoffset, int)
+ assert is_valid_int(memberoffset)
return memberoffset != 0
def op_extract_ushort(combinedoffset):
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
@@ -649,6 +649,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*
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,28 @@
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
+from pypy.rlib.rarithmetic import is_valid_int
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):
@@ -46,15 +62,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 +85,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
@@ -133,7 +149,11 @@
ac = lltype2ctypes(a, normalize=False)
assert isinstance(ac.contents, ctypes.Structure)
assert ac.contents.length == 10
- assert ac.contents._fields_[0] == ('length', ctypes.c_long)
+ if is_emulated_long:
+ lentype = ctypes.c_longlong
+ else:
+ lentype = ctypes.c_long
+ assert ac.contents._fields_[0] == ('length', lentype)
assert ac.contents.items[1] == 101
ac.contents.items[2] = 456
assert a[2] == 456
@@ -144,7 +164,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 +191,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 +243,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 +419,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 +437,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 +463,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 +479,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 +569,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 +579,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 +742,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 +759,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 +878,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 +945,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 +1035,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 +1063,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 +1075,7 @@
return sys.maxint/2 * 3
res = cast_adr_to_int(someaddr())
- assert isinstance(res, int)
+ assert is_valid_int(res)
assert res == -sys.maxint/2 - 3
def test_cast_gcref_back_and_forth(self):
@@ -1299,7 +1328,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 is_valid_int(i)
assert i == llmemory.cast_adr_to_int(a, "forced")
lltype.free(p, flavor='raw')
diff --git a/pypy/rpython/lltypesystem/test/test_llmemory.py b/pypy/rpython/lltypesystem/test/test_llmemory.py
--- a/pypy/rpython/lltypesystem/test/test_llmemory.py
+++ b/pypy/rpython/lltypesystem/test/test_llmemory.py
@@ -1,6 +1,7 @@
from pypy.rpython.lltypesystem.llmemory import *
from pypy.rpython.lltypesystem import lltype
from pypy.rpython.test.test_llinterp import interpret
+from pypy.rlib.rarithmetic import is_valid_int
import py
def test_simple():
@@ -639,12 +640,12 @@
assert cast_int_to_adr(0) == NULL
#
i = cast_adr_to_int(adr, mode="emulated")
- assert type(i) is int
+ assert is_valid_int(i)
i = cast_adr_to_int(NULL, mode="emulated")
- assert type(i) is int and i == 0
+ assert is_valid_int(i) and i == 0
#
i = cast_adr_to_int(adr, mode="forced")
- assert type(i) is int
+ assert is_valid_int(i)
#assert cast_int_to_adr(i) == adr -- depends on ll2ctypes details
i = cast_adr_to_int(NULL, mode="forced")
- assert type(i) is int and i == 0
+ assert is_valid_int(i) and i == 0
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/gc/markcompact.py b/pypy/rpython/memory/gc/markcompact.py
--- a/pypy/rpython/memory/gc/markcompact.py
+++ b/pypy/rpython/memory/gc/markcompact.py
@@ -11,6 +11,8 @@
from pypy.rlib.objectmodel import we_are_translated, running_on_llinterp
from pypy.rpython.lltypesystem import rffi
from pypy.rpython.memory.gcheader import GCHeaderBuilder
+from pypy.rlib.rarithmetic import is_valid_int
+
# Mark'n'compact garbage collector
#
@@ -353,7 +355,7 @@
# like header(), but asserts that we have a forwarding header
hdr = MovingGCBase.header(self, addr)
if not we_are_translated():
- assert isinstance(hdr.tid, int)
+ assert is_valid_int(hdr.tid)
return hdr
def combine(self, typeid16, flags):
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
@@ -738,7 +738,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_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 @@
def attributes_to_mode(attributes):
m = 0
+ attributes = intmask(attributes)
if attributes & win32traits.FILE_ATTRIBUTE_DIRECTORY:
m |= win32traits._S_IFDIR | 0111 # IFEXEC for user,group,other
else:
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
@@ -1,6 +1,8 @@
import py
from pypy.rpython.test.tool import BaseRtypingTest, LLRtypeMixin, OORtypeMixin
from pypy.tool.udir import udir
+from pypy.rlib.rarithmetic import is_valid_int
+
import os
exec 'import %s as posix' % os.name
@@ -18,10 +20,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 is_valid_int(func)
def test_fstat(self):
def fo(fi):
@@ -61,25 +63,25 @@
assert isinstance(times, tuple)
assert len(times) == 5
for value in times:
- assert isinstance(value, int)
+ assert is_valid_int(value)
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
@@ -437,6 +438,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)),
@@ -444,6 +450,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_llinterp.py b/pypy/rpython/test/test_llinterp.py
--- a/pypy/rpython/test/test_llinterp.py
+++ b/pypy/rpython/test/test_llinterp.py
@@ -353,13 +353,16 @@
try:
return ovfcheck((-sys.maxint - 1) % x)
except OverflowError:
- return 1
+ return 43
except ZeroDivisionError:
- return 0
+ return 42
res = interpret(f, [0])
- assert res == 0
+ assert res == 42
+ # the following test doesn't work any more before translation,
+ # but "too bad" is the best answer I suppose
res = interpret(f, [-1])
- assert res == 1
+ if 0:
+ assert res == 43
res = interpret(f, [30])
assert res == (-sys.maxint - 1) % 30
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
@@ -89,6 +98,12 @@
else:
return '%dLL' % value
+def is_positive_nan(value):
+ # bah. we don't have math.copysign() if we're running Python 2.5
+ import struct
+ c = struct.pack("!d", value)[0]
+ return {'\x7f': True, '\xff': False}[c]
+
def name_float(value, db):
if isinf(value):
if value > 0:
@@ -96,7 +111,10 @@
else:
return '(-Py_HUGE_VAL)'
elif isnan(value):
- return '(Py_HUGE_VAL/Py_HUGE_VAL)'
+ if is_positive_nan(value):
+ return '(Py_HUGE_VAL/Py_HUGE_VAL)'
+ else:
+ return '(-(Py_HUGE_VAL/Py_HUGE_VAL))'
else:
x = repr(value)
assert not x.startswith('n')
@@ -112,7 +130,10 @@
return '((float)-Py_HUGE_VAL)'
elif isnan(value):
# XXX are these expressions ok?
- return '((float)(Py_HUGE_VAL/Py_HUGE_VAL))'
+ if is_positive_nan(value):
+ return '((float)(Py_HUGE_VAL/Py_HUGE_VAL))'
+ else:
+ return '(-(float)(Py_HUGE_VAL/Py_HUGE_VAL))'
else:
return repr(value) + 'f'
@@ -172,6 +193,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 +212,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/commondefs.h b/pypy/translator/c/src/commondefs.h
--- a/pypy/translator/c/src/commondefs.h
+++ b/pypy/translator/c/src/commondefs.h
@@ -11,6 +11,21 @@
In particular, Win64 is not supported because it has sizeof(long) == 4.
To fix this, find and review all the places that cast a pointer to a long.
+
+ Update:
+ We are trying to lift this restriction for Win64:
+
+ Win64 int long long long void*
+ --64-bit-- 32 32 64 64
+
+ The migration to this platform is complicated and tedious, because
+ PyPy assumes that a void* fits into a long. Therefore, the created PyPy
+ will (first) have a 64 bit int type. The dependency of sys.maxint must
+ be removed in very many places, and the distinction between Python int
+ and long must be changed in explicit range checks.
+
+ This is work in progress with first successes.
+
*/
#include <limits.h>
@@ -54,16 +69,32 @@
/******************** 64-bit support ********************/
#else
-# if LONG_MAX != 9223372036854775807L
-# error "error in LONG_MAX (64-bit sources but a 32-bit compiler?)"
+# ifndef _WIN64
+# if LONG_MAX != 9223372036854775807L
+# error "error in LONG_MAX (64-bit sources but a 32-bit compiler?)"
+# endif
+# if LONG_MIN != -9223372036854775807L-1L
+# error "unsupported value for LONG_MIN"
+# endif
+
+# define SIZEOF_INT 4
+# define SIZEOF_LONG 8
+# define SIZEOF_LONG_LONG 8
+
+/******************** Win-64 support ********************/
+# else
+# if LONG_MAX != 2147483647L
+# error "error in LONG_MAX (64-bit sources but incompatible compiler?)"
+# endif
+# if LONG_MIN != -2147483647L-1L
+# error "unsupported value for LONG_MIN"
+# endif
+
+# define SIZEOF_INT 4
+# define SIZEOF_LONG 4
+# define SIZEOF_LONG_LONG 8
+
# endif
-# if LONG_MIN != -9223372036854775807L-1L
-# error "unsupported value for LONG_MIN"
-# endif
-
-# define SIZEOF_INT 4
-# define SIZEOF_LONG 8
-# define SIZEOF_LONG_LONG 8
#endif
diff --git a/pypy/translator/c/src/debug_print.c b/pypy/translator/c/src/debug_print.c
--- a/pypy/translator/c/src/debug_print.c
+++ b/pypy/translator/c/src/debug_print.c
@@ -13,6 +13,7 @@
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif
+#include "common_header.h"
#include "src/profiling.h"
#include "src/debug_print.h"
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/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/main.h b/pypy/translator/c/src/main.h
--- a/pypy/translator/c/src/main.h
+++ b/pypy/translator/c/src/main.h
@@ -41,11 +41,14 @@
#endif
instrument_setup();
+#ifndef MS_WINDOWS
+ /* this message does no longer apply to win64 :-) */
if (sizeof(void*) != SIZEOF_LONG) {
errmsg = "only support platforms where sizeof(void*) == sizeof(long),"
" for now";
goto error;
}
+#endif
#ifdef MS_WINDOWS
pypy_Windows_startup();
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,14 +66,20 @@
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;
}
#define pypy_asm_gc_nocollect(f) "/* GC_NOCOLLECT " #f " */"
-#define pypy_asm_keepalive(v) __asm { }
+#ifndef _WIN64
+# define pypy_asm_keepalive(v) __asm { }
+#else
+ /* is there something cheaper? */
+# define pypy_asm_keepalive(v) _ReadWriteBarrier();
+#endif
+
static __declspec(noinline) void pypy_asm_stack_bottom() { }
#define OP_GC_ASMGCROOT_STATIC(i, r) r = \
@@ -86,7 +92,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/goal/win32/gc_patch_windows.py b/pypy/translator/goal/win32/gc_patch_windows.py
--- a/pypy/translator/goal/win32/gc_patch_windows.py
+++ b/pypy/translator/goal/win32/gc_patch_windows.py
@@ -1,6 +1,9 @@
# patches for the Boehm GC for PyPy under Windows
"""
+This file is obsolete now since gc-7.0 / gc-7.1 .
+Please use the instructions in pypy\doc\windows.rst .
+
How to build a pypy compatible version of the Boehm collector
for Windows and Visual Studio .net 2003.
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
@@ -272,8 +272,12 @@
else:
host_factory = OpenBSD_64
elif os.name == 'nt':
- from pypy.translator.platform.windows import Windows
- host_factory = Windows
+ from pypy.translator.platform.windows import Windows, Windows_x64
+ import platform
+ if platform.architecture()[0] == '32bit':
+ host_factory = Windows
+ else:
+ host_factory = Windows_x64
else:
# pray
from pypy.translator.platform.distutils_platform import DistutilsPlatform
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
@@ -11,15 +11,24 @@
if cc == 'mingw32':
return MingwPlatform(cc)
else:
- return MsvcPlatform(cc)
+ return MsvcPlatform(cc, False)
+
+def Windows_x64(cc=None):
+ return MsvcPlatform(cc, True)
-def _get_msvc_env(vsver):
+def _get_msvc_env(vsver, x64flag):
try:
toolsdir = os.environ['VS%sCOMNTOOLS' % vsver]
except KeyError:
return None
- vcvars = os.path.join(toolsdir, 'vsvars32.bat')
+ if x64flag:
+ vsinstalldir = os.path.abspath(os.path.join(toolsdir, '..', '..'))
+ vcinstalldir = os.path.join(vsinstalldir, 'VC')
+ vcbindir = os.path.join(vcinstalldir, 'BIN')
+ vcvars = os.path.join(vcbindir, 'amd64', 'vcvarsamd64.bat')
+ else:
+ vcvars = os.path.join(toolsdir, 'vsvars32.bat')
import subprocess
popen = subprocess.Popen('"%s" & set' % (vcvars,),
@@ -42,21 +51,21 @@
## log.msg("Updated environment with %s" % (vcvars,))
return env
-def find_msvc_env():
+def find_msvc_env(x64flag=False):
# First, try to get the compiler which served to compile python
msc_pos = sys.version.find('MSC v.')
if msc_pos != -1:
msc_ver = int(sys.version[msc_pos+6:msc_pos+10])
# 1300 -> 70, 1310 -> 71, 1400 -> 80, 1500 -> 90
vsver = (msc_ver / 10) - 60
- env = _get_msvc_env(vsver)
+ env = _get_msvc_env(vsver, x64flag)
if env is not None:
return env
# Then, try any other version
for vsver in (100, 90, 80, 71, 70): # All the versions I know
- env = _get_msvc_env(vsver)
+ env = _get_msvc_env(vsver, x64flag)
if env is not None:
return env
@@ -64,13 +73,14 @@
log.error("Could not find a Microsoft Compiler")
# Assume that the compiler is already part of the environment
-msvc_compiler_environ = find_msvc_env()
+msvc_compiler_environ32 = find_msvc_env(False)
+msvc_compiler_environ64 = find_msvc_env(True)
class MsvcPlatform(Platform):
name = "msvc"
so_ext = 'dll'
exe_ext = 'exe'
-
+
relevant_environ = ('PATH', 'INCLUDE', 'LIB')
cc = 'cl.exe'
@@ -81,8 +91,13 @@
standalone_only = ()
shared_only = ()
environ = None
-
+
def __init__(self, cc=None, x64=False):
+ self.x64 = x64
+ if x64:
+ msvc_compiler_environ = msvc_compiler_environ64
+ else:
+ msvc_compiler_environ = msvc_compiler_environ32
Platform.__init__(self, 'cl.exe')
if msvc_compiler_environ:
self.c_environ = os.environ.copy()
@@ -288,7 +303,10 @@
('CC_LINK', self.link),
('LINKFILES', eci.link_files),
('MASM', self.masm),
+ ('_WIN32', '1'),
]
+ if self.x64:
+ definitions.append(('_WIN64', '1'))
for args in definitions:
m.definition(*args)
diff --git a/pypy/translator/tool/cbuild.py b/pypy/translator/tool/cbuild.py
--- a/pypy/translator/tool/cbuild.py
+++ b/pypy/translator/tool/cbuild.py
@@ -320,4 +320,13 @@
#define __XSI_VISIBLE 700
/* Windows: winsock/winsock2 mess */
#define WIN32_LEAN_AND_MEAN
+#ifdef _WIN64
+ typedef __int64 Signed;
+ typedef unsigned __int64 Unsigned;
+# define SIGNED_MIN LLONG_MIN
+#else
+ typedef long Signed;
+ typedef unsigned long Unsigned;
+# define SIGNED_MIN LONG_MIN
+#endif
'''
More information about the pypy-commit
mailing list