Author: Brian Kearns <bdkea...@gmail.com>
Branch: use-file-star-for-file
Changeset: r73580:2ea2f1aeea40
Date: 2014-09-17 11:55 -0400
http://bitbucket.org/pypy/pypy/changeset/2ea2f1aeea40/
Log: merge default
diff --git a/pypy/doc/getting-started-python.rst
b/pypy/doc/getting-started-python.rst
--- a/pypy/doc/getting-started-python.rst
+++ b/pypy/doc/getting-started-python.rst
@@ -111,6 +111,10 @@
of your choice. Typical example: ``--opt=2`` gives a good (but of
course slower) Python interpreter without the JIT.
+ Consider using PyPy instead of CPython in the above command line,
+ as it is much faster. (Note that ``rpython`` is a Python 2 program,
+ not Python 3; you need to run either PyPy 2 or CPython 2.)
+
.. _`optimization level`: config/opt.html
If everything works correctly this will create an executable
diff --git a/pypy/doc/windows.rst b/pypy/doc/windows.rst
--- a/pypy/doc/windows.rst
+++ b/pypy/doc/windows.rst
@@ -85,10 +85,13 @@
Abridged method (for -Ojit builds using Visual Studio 2008)
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-Download the versions of all the external packages
-from
+Download the versions of all the external packages from
+https://bitbucket.org/pypy/pypy/downloads/local_2.4.zip
+(for 2.4 release and later) or
https://bitbucket.org/pypy/pypy/downloads/local.zip
-Then expand it into the base directory (base_dir) and modify your environment
to reflect this::
+(for pre-2.4 versions)
+Then expand it into the base directory (base_dir) and modify your environment
+to reflect this::
set PATH=<base_dir>\bin;<base_dir>\tcltk\bin;%PATH%
set INCLUDE=<base_dir>\include;<base_dir>\tcltk\include;%INCLUDE%
diff --git a/pypy/interpreter/pycode.py b/pypy/interpreter/pycode.py
--- a/pypy/interpreter/pycode.py
+++ b/pypy/interpreter/pycode.py
@@ -38,18 +38,15 @@
def cpython_code_signature(code):
"([list-of-arg-names], vararg-name-or-None, kwarg-name-or-None)."
argcount = code.co_argcount
+ varnames = code.co_varnames
assert argcount >= 0 # annotator hint
- argnames = list(code.co_varnames[:argcount])
+ argnames = list(varnames[:argcount])
if code.co_flags & CO_VARARGS:
- varargname = code.co_varnames[argcount]
+ varargname = varnames[argcount]
argcount += 1
else:
varargname = None
- if code.co_flags & CO_VARKEYWORDS:
- kwargname = code.co_varnames[argcount]
- argcount += 1
- else:
- kwargname = None
+ kwargname = varnames[argcount] if code.co_flags & CO_VARKEYWORDS else None
return Signature(argnames, varargname, kwargname)
diff --git a/pypy/interpreter/test/test_app_main.py
b/pypy/interpreter/test/test_app_main.py
--- a/pypy/interpreter/test/test_app_main.py
+++ b/pypy/interpreter/test/test_app_main.py
@@ -971,7 +971,7 @@
prefix = udir.join('pathtest').ensure(dir=1)
fake_exe = 'bin/pypy-c'
if sys.platform == 'win32':
- fake_exe += '.exe'
+ fake_exe = 'pypy-c.exe'
fake_exe = prefix.join(fake_exe).ensure(file=1)
expected_path = [str(prefix.join(subdir).ensure(dir=1))
for subdir in ('lib_pypy',
@@ -1011,8 +1011,10 @@
assert sys.path == old_sys_path + [self.goal_dir]
app_main.setup_bootstrap_path(self.fake_exe)
- assert sys.executable == '' # not executable!
- assert sys.path == old_sys_path + [self.goal_dir]
+ if not sys.platform == 'win32':
+ # an existing file is always 'executable' on windows
+ assert sys.executable == '' # not executable!
+ assert sys.path == old_sys_path + [self.goal_dir]
os.chmod(self.fake_exe, 0755)
app_main.setup_bootstrap_path(self.fake_exe)
diff --git a/pypy/module/_cffi_backend/ctypefunc.py
b/pypy/module/_cffi_backend/ctypefunc.py
--- a/pypy/module/_cffi_backend/ctypefunc.py
+++ b/pypy/module/_cffi_backend/ctypefunc.py
@@ -8,6 +8,7 @@
from rpython.rlib.jit_libffi import (CIF_DESCRIPTION, CIF_DESCRIPTION_P,
FFI_TYPE, FFI_TYPE_P, FFI_TYPE_PP, SIZE_OF_FFI_ARG)
from rpython.rlib.objectmodel import we_are_translated, instantiate
+from rpython.rlib.objectmodel import keepalive_until_here
from rpython.rtyper.lltypesystem import lltype, llmemory, rffi
from pypy.interpreter.error import OperationError, oefmt
@@ -160,6 +161,7 @@
raw_cdata = rffi.cast(rffi.CCHARPP, data)[0]
lltype.free(raw_cdata, flavor='raw')
lltype.free(buffer, flavor='raw')
+ keepalive_until_here(args_w)
return w_res
def get_mustfree_flag(data):
diff --git a/pypy/module/_ssl/interp_ssl.py b/pypy/module/_ssl/interp_ssl.py
--- a/pypy/module/_ssl/interp_ssl.py
+++ b/pypy/module/_ssl/interp_ssl.py
@@ -759,17 +759,25 @@
# socket's timeout is in seconds, poll's timeout in ms
timeout = int(sock_timeout * 1000 + 0.5)
- ready = rpoll.poll(fddict, timeout)
+ try:
+ ready = rpoll.poll(fddict, timeout)
+ except rpoll.PollError, e:
+ message = e.get_msg()
+ raise ssl_error(space, message, e.errno)
else:
if MAX_FD_SIZE is not None and sock_fd >= MAX_FD_SIZE:
return SOCKET_TOO_LARGE_FOR_SELECT
- if writing:
- r, w, e = rpoll.select([], [sock_fd], [], sock_timeout)
- ready = w
- else:
- r, w, e = rpoll.select([sock_fd], [], [], sock_timeout)
- ready = r
+ try:
+ if writing:
+ r, w, e = rpoll.select([], [sock_fd], [], sock_timeout)
+ ready = w
+ else:
+ r, w, e = rpoll.select([sock_fd], [], [], sock_timeout)
+ ready = r
+ except rpoll.SelectError as e:
+ message = e.get_msg()
+ raise ssl_error(space, message, e.errno)
if ready:
return SOCKET_OPERATION_OK
else:
diff --git a/pypy/module/operator/__init__.py b/pypy/module/operator/__init__.py
--- a/pypy/module/operator/__init__.py
+++ b/pypy/module/operator/__init__.py
@@ -39,7 +39,7 @@
'irshift', 'isub', 'itruediv', 'ixor', '_length_hint']
interpleveldefs = {
- '_compare_digest': 'interp_operator.compare_digest',
+ '_compare_digest': 'tscmp.compare_digest',
}
for name in interp_names:
diff --git a/pypy/module/operator/app_operator.py
b/pypy/module/operator/app_operator.py
--- a/pypy/module/operator/app_operator.py
+++ b/pypy/module/operator/app_operator.py
@@ -5,6 +5,7 @@
equivalent to x+y.
'''
from __pypy__ import builtinify
+
import types
@@ -27,7 +28,7 @@
'getslice(a, b, c) -- Same as a[b:c].'
if not isinstance(start, int) or not isinstance(end, int):
raise TypeError("an integer is expected")
- return a[start:end]
+ return a[start:end]
__getslice__ = getslice
def indexOf(a, b):
@@ -37,7 +38,7 @@
if x == b:
return index
index += 1
- raise ValueError, 'sequence.index(x): x not in sequence'
+ raise ValueError('sequence.index(x): x not in sequence')
def isMappingType(obj,):
'isMappingType(a) -- Return True if a has a mapping type, False otherwise.'
@@ -58,9 +59,9 @@
def repeat(obj, num):
'repeat(a, b) -- Return a * b, where a is a sequence, and b is an integer.'
if not isinstance(num, (int, long)):
- raise TypeError, 'an integer is required'
+ raise TypeError('an integer is required')
if not isSequenceType(obj):
- raise TypeError, "non-sequence object can't be repeated"
+ raise TypeError("non-sequence object can't be repeated")
return obj * num
@@ -68,59 +69,85 @@
def setslice(a, b, c, d):
'setslice(a, b, c, d) -- Same as a[b:c] = d.'
- a[b:c] = d
+ a[b:c] = d
__setslice__ = setslice
+def _resolve_attr_chain(chain, obj, idx=0):
+ obj = getattr(obj, chain[idx])
+ if idx + 1 == len(chain):
+ return obj
+ else:
+ return _resolve_attr_chain(chain, obj, idx + 1)
+
+
+class _simple_attrgetter(object):
+ def __init__(self, attr):
+ self._attr = attr
+
+ def __call__(self, obj):
+ return getattr(obj, self._attr)
+
+
+class _single_attrgetter(object):
+ def __init__(self, attrs):
+ self._attrs = attrs
+
+ def __call__(self, obj):
+ return _resolve_attr_chain(self._attrs, obj)
+
+
+class _multi_attrgetter(object):
+ def __init__(self, attrs):
+ self._attrs = attrs
+
+ def __call__(self, obj):
+ return tuple([
+ _resolve_attr_chain(attrs, obj)
+ for attrs in self._attrs
+ ])
+
+
def attrgetter(attr, *attrs):
+ if (
+ not isinstance(attr, basestring) or
+ not all(isinstance(a, basestring) for a in attrs)
+ ):
+ def _raise_typeerror(obj):
+ raise TypeError(
+ "argument must be a string, not %r" % type(attr).__name__
+ )
+ return _raise_typeerror
if attrs:
- getters = [single_attr_getter(a) for a in (attr,) + attrs]
- def getter(obj):
- return tuple([getter(obj) for getter in getters])
+ return _multi_attrgetter([
+ a.split(".") for a in [attr] + list(attrs)
+ ])
+ elif "." not in attr:
+ return _simple_attrgetter(attr)
else:
- getter = single_attr_getter(attr)
- return builtinify(getter)
+ return _single_attrgetter(attr.split("."))
-def single_attr_getter(attr):
- if not isinstance(attr, str):
- if not isinstance(attr, unicode):
- def _raise_typeerror(obj):
- raise TypeError("argument must be a string, not %r" %
- (type(attr).__name__,))
- return _raise_typeerror
- attr = attr.encode('ascii')
- #
- def make_getter(name, prevfn=None):
- if prevfn is None:
- def getter(obj):
- return getattr(obj, name)
+
+class itemgetter(object):
+ def __init__(self, item, *items):
+ self._single = not bool(items)
+ if self._single:
+ self._idx = item
else:
- def getter(obj):
- return getattr(prevfn(obj), name)
- return getter
- #
- last = 0
- getter = None
- while True:
- dot = attr.find(".", last)
- if dot < 0: break
- getter = make_getter(attr[last:dot], getter)
- last = dot + 1
- return make_getter(attr[last:], getter)
+ self._idx = [item] + list(items)
+ def __call__(self, obj):
+ if self._single:
+ return obj[self._idx]
+ else:
+ return tuple([obj[i] for i in self._idx])
-def itemgetter(item, *items):
- if items:
- list_of_indices = [item] + list(items)
- def getter(obj):
- return tuple([obj[i] for i in list_of_indices])
- else:
- def getter(obj):
- return obj[item]
- return builtinify(getter)
+class methodcaller(object):
+ def __init__(self, method_name, *args, **kwargs):
+ self._method_name = method_name
+ self._args = args
+ self._kwargs = kwargs
-def methodcaller(method_name, *args, **kwargs):
- def call(obj):
- return getattr(obj, method_name)(*args, **kwargs)
- return builtinify(call)
+ def __call__(self, obj):
+ return getattr(obj, self._method_name)(*self._args, **self._kwargs)
diff --git a/pypy/module/operator/interp_operator.py
b/pypy/module/operator/interp_operator.py
--- a/pypy/module/operator/interp_operator.py
+++ b/pypy/module/operator/interp_operator.py
@@ -1,6 +1,4 @@
-from rpython.rlib.objectmodel import specialize
-
-from pypy.interpreter.error import OperationError, oefmt
+from pypy.interpreter.error import OperationError
from pypy.interpreter.gateway import unwrap_spec
@@ -249,33 +247,3 @@
@unwrap_spec(default=int)
def _length_hint(space, w_iterable, default):
return space.wrap(space.length_hint(w_iterable, default))
-
-def compare_digest(space, w_a, w_b):
- if (
- space.isinstance_w(w_a, space.w_unicode) and
- space.isinstance_w(w_b, space.w_unicode)
- ):
- return space.wrap(tscmp(space.unicode_w(w_a), space.unicode_w(w_b)))
- if (
- space.isinstance_w(w_a, space.w_unicode) or
- space.isinstance_w(w_b, space.w_unicode)
- ):
- raise oefmt(
- space.w_TypeError,
- "unsupported operand types(s) or combination of types: '%N' and
'%N'",
- w_a,
- w_b,
- )
- else:
- return space.wrap(tscmp(space.bufferstr_w(w_a),
space.bufferstr_w(w_b)))
-
-
-@specialize.argtype(0, 1)
-def tscmp(a, b):
- len_a = len(a)
- len_b = len(b)
- length = min(len(a), len(b))
- res = len_a ^ len_b
- for i in xrange(length):
- res |= ord(a[i]) ^ ord(b[i])
- return res == 0
diff --git a/pypy/module/operator/test/test_operator.py
b/pypy/module/operator/test/test_operator.py
--- a/pypy/module/operator/test/test_operator.py
+++ b/pypy/module/operator/test/test_operator.py
@@ -334,3 +334,9 @@
assert operator._compare_digest(a, b)
a, b = mybytes(b"foobar"), mybytes(b"foobaz")
assert not operator._compare_digest(a, b)
+
+ def test_compare_digest_unicode(self):
+ import operator
+ assert operator._compare_digest(u'asd', u'asd')
+ assert not operator._compare_digest(u'asd', u'qwe')
+ raises(TypeError, operator._compare_digest, u'asd', b'qwe')
diff --git a/pypy/module/operator/test/test_tscmp.py
b/pypy/module/operator/test/test_tscmp.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/operator/test/test_tscmp.py
@@ -0,0 +1,28 @@
+from pypy.module.operator.tscmp import pypy_tscmp, pypy_tscmp_wide
+
+class TestTimingSafeCompare:
+ tostr = str
+ tscmp = staticmethod(pypy_tscmp)
+
+ def test_tscmp_neq(self):
+ assert not self.tscmp(self.tostr('asd'), self.tostr('qwe'), 3, 3)
+
+ def test_tscmp_eq(self):
+ assert self.tscmp(self.tostr('asd'), self.tostr('asd'), 3, 3)
+
+ def test_tscmp_len(self):
+ assert self.tscmp(self.tostr('asdp'), self.tostr('asdq'), 3, 3)
+
+ def test_tscmp_nlen(self):
+ assert not self.tscmp(self.tostr('asd'), self.tostr('asd'), 2, 3)
+
+
+class TestTimingSafeCompareWide(TestTimingSafeCompare):
+ tostr = unicode
+ tscmp = staticmethod(pypy_tscmp_wide)
+
+ def test_tscmp_wide_nonascii(self):
+ a, b = u"\ud808\udf45", u"\ud808\udf45"
+ assert self.tscmp(a, b, len(a), len(b))
+ a, b = u"\ud808\udf45", u"\ud808\udf45 "
+ assert not self.tscmp(a, b, len(a), len(b))
diff --git a/pypy/module/operator/tscmp.c b/pypy/module/operator/tscmp.c
new file mode 100644
--- /dev/null
+++ b/pypy/module/operator/tscmp.c
@@ -0,0 +1,80 @@
+/* Derived from CPython 3.3.5's operator.c::_tscmp
+ */
+
+#include <stdlib.h>
+#include <wchar.h>
+#include "tscmp.h"
+
+int
+pypy_tscmp(const char *a, const char *b, long len_a, long len_b)
+{
+ /* The volatile type declarations make sure that the compiler has no
+ * chance to optimize and fold the code in any way that may change
+ * the timing.
+ */
+ volatile long length;
+ volatile const char *left;
+ volatile const char *right;
+ long i;
+ char result;
+
+ /* loop count depends on length of b */
+ length = len_b;
+ left = NULL;
+ right = b;
+
+ /* don't use else here to keep the amount of CPU instructions constant,
+ * volatile forces re-evaluation
+ * */
+ if (len_a == length) {
+ left = *((volatile const char**)&a);
+ result = 0;
+ }
+ if (len_a != length) {
+ left = b;
+ result = 1;
+ }
+
+ for (i=0; i < length; i++) {
+ result |= *left++ ^ *right++;
+ }
+
+ return (result == 0);
+}
+
+int
+pypy_tscmp_wide(const wchar_t *a, const wchar_t *b, long len_a, long len_b)
+{
+ /* The volatile type declarations make sure that the compiler has no
+ * chance to optimize and fold the code in any way that may change
+ * the timing.
+ */
+ volatile long length;
+ volatile const wchar_t *left;
+ volatile const wchar_t *right;
+ long i;
+ wchar_t result;
+
+ /* loop count depends on length of b */
+ length = len_b;
+ left = NULL;
+ right = b;
+
+ /* don't use else here to keep the amount of CPU instructions constant,
+ * volatile forces re-evaluation
+ * */
+ if (len_a == length) {
+ left = *((volatile const wchar_t**)&a);
+ result = 0;
+ }
+ if (len_a != length) {
+ left = b;
+ result = 1;
+ }
+
+ for (i=0; i < length; i++) {
+ result |= *left++ ^ *right++;
+ }
+
+ return (result == 0);
+}
diff --git a/pypy/module/operator/tscmp.h b/pypy/module/operator/tscmp.h
new file mode 100644
--- /dev/null
+++ b/pypy/module/operator/tscmp.h
@@ -0,0 +1,2 @@
+int pypy_tscmp(const char *, const char *, long, long);
+int pypy_tscmp_wide(const wchar_t *, const wchar_t *, long, long);
diff --git a/pypy/module/operator/tscmp.py b/pypy/module/operator/tscmp.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/operator/tscmp.py
@@ -0,0 +1,73 @@
+"""
+Provides _compare_digest method, which is a safe comparing to prevent timing
+attacks for the hmac module.
+"""
+import py
+
+from rpython.rtyper.lltypesystem import lltype, rffi
+from rpython.translator.tool.cbuild import ExternalCompilationInfo
+
+from pypy.interpreter.error import oefmt
+
+cwd = py.path.local(__file__).dirpath()
+eci = ExternalCompilationInfo(
+ includes=[cwd.join('tscmp.h')],
+ include_dirs=[str(cwd)],
+ separate_module_files=[cwd.join('tscmp.c')],
+ export_symbols=['pypy_tscmp', 'pypy_tscmp_wide'])
+
+
+def llexternal(*args, **kwargs):
+ kwargs.setdefault('compilation_info', eci)
+ kwargs.setdefault('sandboxsafe', True)
+ return rffi.llexternal(*args, **kwargs)
+
+
+pypy_tscmp = llexternal(
+ 'pypy_tscmp',
+ [rffi.CCHARP, rffi.CCHARP, rffi.LONG, rffi.LONG],
+ rffi.INT)
+pypy_tscmp_wide = llexternal(
+ 'pypy_tscmp_wide',
+ [rffi.CWCHARP, rffi.CWCHARP, rffi.LONG, rffi.LONG],
+ rffi.INT)
+
+
+def compare_digest(space, w_a, w_b):
+ """compare_digest(a, b) -> bool
+
+ Return 'a == b'. This function uses an approach designed to prevent
+ timing analysis, making it appropriate for cryptography. a and b
+ must both be of the same type: either str (ASCII only), or any type
+ that supports the buffer protocol (e.g. bytes).
+
+ Note: If a and b are of different lengths, or if an error occurs, a
+ timing attack could theoretically reveal information about the types
+ and lengths of a and b--but not their values.
+ """
+ if (space.isinstance_w(w_a, space.w_unicode) and
+ space.isinstance_w(w_b, space.w_unicode)):
+ a = space.unicode_w(w_a)
+ b = space.unicode_w(w_b)
+ with rffi.scoped_nonmoving_unicodebuffer(a) as a_buf:
+ with rffi.scoped_nonmoving_unicodebuffer(b) as b_buf:
+ result = pypy_tscmp_wide(a_buf, b_buf, len(a), len(b))
+ return space.wrap(rffi.cast(lltype.Bool, result))
+ return compare_digest_buffer(space, w_a, w_b)
+
+
+def compare_digest_buffer(space, w_a, w_b):
+ try:
+ a_buf = w_a.buffer_w(space, space.BUF_SIMPLE)
+ b_buf = w_b.buffer_w(space, space.BUF_SIMPLE)
+ except TypeError:
+ raise oefmt(space.w_TypeError,
+ "unsupported operand types(s) or combination of types: "
+ "'%T' and '%T'", w_a, w_b)
+
+ a = a_buf.as_str()
+ b = b_buf.as_str()
+ with rffi.scoped_nonmovingbuffer(a) as a_buf:
+ with rffi.scoped_nonmovingbuffer(b) as b_buf:
+ result = pypy_tscmp(a_buf, b_buf, len(a), len(b))
+ return space.wrap(rffi.cast(lltype.Bool, result))
diff --git a/rpython/jit/backend/arm/callbuilder.py
b/rpython/jit/backend/arm/callbuilder.py
--- a/rpython/jit/backend/arm/callbuilder.py
+++ b/rpython/jit/backend/arm/callbuilder.py
@@ -92,7 +92,8 @@
self.mc.LDR_ri(r.r7.value, r.r5.value)
# change 'rpy_fastgil' to 0 (it should be non-zero right now)
- self.mc.DMB()
+ if self.asm.cpu.cpuinfo.arch_version >= 7:
+ self.mc.DMB()
self.mc.gen_load_int(r.r6.value, fastgil)
self.mc.MOV_ri(r.ip.value, 0)
self.mc.STR_ri(r.ip.value, r.r6.value)
@@ -112,7 +113,8 @@
self.mc.STREX(r.r3.value, r.ip.value, r.r6.value, c=c.EQ)
# try to claim the lock
self.mc.CMP_ri(r.r3.value, 0, cond=c.EQ) # did this succeed?
- self.mc.DMB()
+ if self.asm.cpu.cpuinfo.arch_version >= 7:
+ self.mc.DMB()
# the success of the lock acquisition is defined by
# 'EQ is true', or equivalently by 'r3 == 0'.
#
diff --git a/rpython/jit/backend/arm/codebuilder.py
b/rpython/jit/backend/arm/codebuilder.py
--- a/rpython/jit/backend/arm/codebuilder.py
+++ b/rpython/jit/backend/arm/codebuilder.py
@@ -333,6 +333,8 @@
| (rn & 0xF) << 16)
def DMB(self):
+ # ARMv7 only. I guess ARMv6 CPUs cannot be used in symmetric
+ # multi-processing at all? That would make this instruction unneeded.
# note: 'cond' is only permitted on Thumb here, but don't
# write literally 0xf57ff05f, because it's larger than 31 bits
c = cond.AL
diff --git a/rpython/jit/backend/arm/instructions.py
b/rpython/jit/backend/arm/instructions.py
--- a/rpython/jit/backend/arm/instructions.py
+++ b/rpython/jit/backend/arm/instructions.py
@@ -142,6 +142,7 @@
#'VCVT' : {'opc1':0xB, 'opc2':0xE, 'opc3':0x1, 'base': False},
}
+# ARMv7 only
simd_instructions_3regs = {
'VADD_i64': {'A': 0x8, 'B': 0, 'U': 0},
'VSUB_i64': {'A': 0x8, 'B': 0, 'U': 1},
diff --git a/rpython/jit/backend/llsupport/rewrite.py
b/rpython/jit/backend/llsupport/rewrite.py
--- a/rpython/jit/backend/llsupport/rewrite.py
+++ b/rpython/jit/backend/llsupport/rewrite.py
@@ -1,3 +1,4 @@
+from rpython.rlib import rgc
from rpython.rlib.rarithmetic import ovfcheck
from rpython.rtyper.lltypesystem import llmemory
from rpython.jit.metainterp import history
@@ -390,8 +391,8 @@
val = op.getarg(0)
if val not in self.write_barrier_applied:
v = op.getarg(1)
- if isinstance(v, BoxPtr) or (isinstance(v, ConstPtr) and
- bool(v.value)): # store a non-NULL
+ if (isinstance(v, BoxPtr) or (isinstance(v, ConstPtr) and
+ rgc.needs_write_barrier(v.value))):
self.gen_write_barrier(val)
#op = op.copy_and_change(rop.SETFIELD_RAW)
self.newops.append(op)
@@ -400,8 +401,8 @@
val = op.getarg(0)
if val not in self.write_barrier_applied:
v = op.getarg(2)
- if isinstance(v, BoxPtr) or (isinstance(v, ConstPtr) and
- bool(v.value)): # store a non-NULL
+ if (isinstance(v, BoxPtr) or (isinstance(v, ConstPtr) and
+ rgc.needs_write_barrier(v.value))):
self.gen_write_barrier_array(val, op.getarg(1))
#op = op.copy_and_change(rop.SET{ARRAYITEM,INTERIORFIELD}_RAW)
self.newops.append(op)
diff --git a/rpython/rlib/rgc.py b/rpython/rlib/rgc.py
--- a/rpython/rlib/rgc.py
+++ b/rpython/rlib/rgc.py
@@ -86,6 +86,14 @@
collect(i)
i += 1
+def needs_write_barrier(obj):
+ """ We need to emit write barrier if the right hand of assignment
+ is in nursery, used by the JIT for handling set*_gc(Const)
+ """
+ if not obj:
+ return False
+ return can_move(obj)
+
def _heap_stats():
raise NotImplementedError # can't be run directly
diff --git a/rpython/rtyper/module/ll_os_stat.py
b/rpython/rtyper/module/ll_os_stat.py
--- a/rpython/rtyper/module/ll_os_stat.py
+++ b/rpython/rtyper/module/ll_os_stat.py
@@ -186,7 +186,10 @@
_name_struct_stat = '_stati64'
INCLUDES = ['sys/types.h', 'sys/stat.h', 'sys/statvfs.h']
else:
- _name_struct_stat = 'stat'
+ if sys.platform.startswith('linux'):
+ _name_struct_stat = 'stat64'
+ else:
+ _name_struct_stat = 'stat'
INCLUDES = ['sys/types.h', 'sys/stat.h', 'sys/statvfs.h', 'unistd.h']
compilation_info = ExternalCompilationInfo(
diff --git a/rpython/translator/platform/test/test_makefile.py
b/rpython/translator/platform/test/test_makefile.py
--- a/rpython/translator/platform/test/test_makefile.py
+++ b/rpython/translator/platform/test/test_makefile.py
@@ -44,6 +44,7 @@
assert res.returncode == 0
def test_900_files(self):
+ tmpdir = udir.join('test_900_files').ensure(dir=1)
txt = '#include <stdio.h>\n'
for i in range(900):
txt += 'int func%03d();\n' % i
@@ -52,11 +53,11 @@
txt += ' j += func%03d();\n' % i
txt += ' printf("%d\\n", j);\n'
txt += ' return 0;};\n'
- cfile = udir.join('test_900_files.c')
+ cfile = tmpdir.join('test_900_files.c')
cfile.write(txt)
cfiles = [cfile]
for i in range(900):
- cfile2 = udir.join('implement%03d.c' %i)
+ cfile2 = tmpdir.join('implement%03d.c' %i)
cfile2.write('''
int func%03d()
{
@@ -64,10 +65,10 @@
}
''' % (i, i))
cfiles.append(cfile2)
- mk = self.platform.gen_makefile(cfiles, ExternalCompilationInfo(),
path=udir)
+ mk = self.platform.gen_makefile(cfiles, ExternalCompilationInfo(),
path=tmpdir)
mk.write()
self.platform.execute_makefile(mk)
- res = self.platform.execute(udir.join('test_900_files'))
+ res = self.platform.execute(tmpdir.join('test_900_files'))
self.check_res(res, '%d\n' %sum(range(900)))
def test_precompiled_headers(self):
diff --git a/rpython/translator/platform/windows.py
b/rpython/translator/platform/windows.py
--- a/rpython/translator/platform/windows.py
+++ b/rpython/translator/platform/windows.py
@@ -203,6 +203,9 @@
# 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 order of parameters! ;-)
+ pdb_dir = oname.dirname
+ if pdb_dir:
+ compile_args += ['/Fd%s\\' % (pdb_dir,)]
args = ['/nologo', '/c'] + compile_args + ['/Fo%s' % (oname,),
str(cfile)]
self._execute_c_compiler(cc, args, oname)
return oname
diff --git a/rpython/translator/sandbox/rsandbox.py
b/rpython/translator/sandbox/rsandbox.py
--- a/rpython/translator/sandbox/rsandbox.py
+++ b/rpython/translator/sandbox/rsandbox.py
@@ -60,8 +60,7 @@
def need_more_data(self):
buflen = self.buflen
- buf = lltype.malloc(rffi.CCHARP.TO, buflen, flavor='raw')
- try:
+ with lltype.scoped_alloc(rffi.CCHARP.TO, buflen) as buf:
buflen = rffi.cast(rffi.SIZE_T, buflen)
count = ll_read_not_sandboxed(self.fd, buf, buflen)
count = rffi.cast(lltype.Signed, count)
@@ -69,20 +68,15 @@
raise IOError
self.buf += ''.join([buf[i] for i in range(count)])
self.buflen *= 2
- finally:
- lltype.free(buf, flavor='raw')
def sandboxed_io(buf):
STDIN = 0
STDOUT = 1
# send the buffer with the marshalled fnname and input arguments to STDOUT
- p = lltype.malloc(rffi.CCHARP.TO, len(buf), flavor='raw')
- try:
+ with lltype.scoped_alloc(rffi.CCHARP.TO, len(buf)) as p:
for i in range(len(buf)):
p[i] = buf[i]
writeall_not_sandboxed(STDOUT, p, len(buf))
- finally:
- lltype.free(p, flavor='raw')
# build a Loader that will get the answer from STDIN
loader = FdLoader(STDIN)
# check for errors
@@ -108,9 +102,8 @@
@signature(types.str(), returns=types.impossible())
def not_implemented_stub(msg):
STDERR = 2
- buf = rffi.str2charp(msg + '\n')
- writeall_not_sandboxed(STDERR, buf, len(msg) + 1)
- rffi.free_charp(buf)
+ with rffi.scoped_str2charp(msg + '\n') as buf:
+ writeall_not_sandboxed(STDERR, buf, len(msg) + 1)
raise RuntimeError(msg) # XXX in RPython, the msg is ignored at the moment
dump_string = rmarshal.get_marshaller(str)
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
