* Wed Jan 5 2011 David Malcolm <dmalcolm@redhat.com> - 1.4.1-4

- rebuild pypy using itself, for speed, with a boolean to break this cycle in
the build-requirement graph (falling back to using "python-devel" aka CPython)
- add work-in-progress patch to try to make generated c more readable
(rhbz#666963)
- capture the RPython source code files from the build within the debuginfo
package (rhbz#666975)

pypy-1.4.1-more-readable-c-code.patch

@@ -0,0 +1,695 @@
+diff -r cd083843b67a pypy/interpreter/pycode.py
+--- a/pypy/interpreter/pycode.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/interpreter/pycode.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -14,6 +14,7 @@
+ from pypy.interpreter.astcompiler.consts import (CO_OPTIMIZED,
+     CO_OPTIMIZED, CO_NEWLOCALS, CO_VARARGS, CO_VARKEYWORDS, CO_NESTED,
+     CO_GENERATOR, CO_CONTAINSGLOBALS)
++from pypy.interpreter.pytraceback import offset2lineno
+ from pypy.rlib.rarithmetic import intmask
+ from pypy.rlib.debug import make_sure_not_resized
+ from pypy.rlib import jit
+@@ -81,6 +82,7 @@
+         self.hidden_applevel = hidden_applevel
+         self.magic = magic
+         self._signature = cpython_code_signature(self)
++        self._cached_source = None
+         self._initialize()
+ 
+     def _initialize(self):
+@@ -403,3 +405,25 @@
+     def repr(self, space):
+         return space.wrap(self.get_repr())
+     repr.unwrap_spec = ['self', ObjSpace]
++
++    def get_linenum_for_offset(self, offset):
++        # Given a bytecode offset, return a 1-based index into the lines of the
++        # source code
++        return offset2lineno(self, offset)
++
++    def _ensure_source(self):
++        # Lazily grab the source lines into self._cached_source (or raise
++        # an IOError)
++        if not self._cached_source:
++            f = open(self.co_filename, 'r')
++            source = [line.rstrip() for line in f.readlines()]
++            f.close()
++            self._cached_source = source
++    
++    def get_source_text(self, linenum):
++        # Given a 1-based index, get the corresponding line of source code (or
++        # raise an IOError)
++        self._ensure_source()
++        return self._cached_source[linenum - 1]
++
++        
+diff -r cd083843b67a pypy/objspace/flow/model.py
+--- a/pypy/objspace/flow/model.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/objspace/flow/model.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -31,6 +31,120 @@
+ 
+ __metaclass__ = type
+ 
++class SourceLoc(object):
++    # A srcloc is a specific location within the RPython source code,
++    # intended for human display
++    __slots__ = ('code', # code object
++                 'linenum' # 1-based index, as displayed to a user
++                 )
++    def __init__(self, code, linenum):
++        self.code = code
++        self.linenum = linenum
++
++    def get_text(self):
++        # Get the actual source text of this line
++        return self.code.get_source_text(self.linenum)
++
++    def __eq__(self, other):
++        return self.code == other.code and self.linenum == other.linenum
++
++    def __ne__(self, other):
++        if other:
++            return self.code != other.code or self.linenum != other.linenum
++        else:
++            return True
++
++class CodeLoc(object):
++    # A codeloc is a specific location within the RPython bytecode
++    __slots__ = ('code', # code object
++                 'offset' # int index into bytecode, or -1
++                 )
++
++    def __init__(self, code, offset):
++        self.code = code
++        self.offset = offset
++
++    def __str__(self):
++        if self.offset >= 0:
++            return "%s@%d" % (self.code.co_name, self.offset)
++        else:
++            return ""
++
++    def __ne__(self, other):
++        if other:
++            return self.code != other.code or self.offset != other.offset
++        else:
++            return True
++
++    def __cmp__(self, other):
++        # Partial ordering, for those locations that have an offset:
++        if other:
++            if self.offset >= 0 and other.offset >= 0:
++                return self.offset - other.offset
++        return 0
++
++    def get_source_loc(self):
++        # Convert to a SourceLoc:
++        return SourceLoc(self.code, self.code.get_linenum_for_offset(self.offset))
++
++class OperationLoc(object):
++    # An oploc is the location within the RPython source code of a given
++    # operation
++    # 
++    # This is a list consisting of CodeLoc instances, some of which may be None
++    #
++    # For the simple case, this is list of length 1 with a single CodeLoc
++    #
++    # For an operation inside an inlined callsite, we have a list of length 2:
++    #    [codeloc of callsite,
++    #     codeloc of operation within inlined body]
++    #
++    # For more interesting inlined cases, we have a chain of source locations:
++    #    [codeloc of callsite,
++    #     codeloc of inner callsite,
++    #     ... ,
++    #     codeloc of innermost inlined callsite,
++    #     codeloc of operation within inlined body]
++    #
++
++    __slots__ = ('codelocs', )
++
++    def __init__(self, codelocs):
++        self.codelocs = codelocs
++
++    def __str__(self):
++        return '[' + ' > '.join(str(codeloc) for codeloc in self.codelocs) + ']'
++
++    def __cmp__(self, other):
++        return cmp(self.codelocs, other.codelocs)
++
++def block_comparator(blk0, blk1):
++    '''
++    Sort function for blocks, putting them in an ordering that attempts to
++    maximize readability of the generated C code
++    '''
++    # print 'comparing %r and %r' % (blk0, blk1)
++    # Put the start/end block at the top/bottom:
++    if blk0.isstartblock:
++        return -1
++
++    if blk1.isstartblock:
++        return 1
++
++    # Order blocks by the offset, where present:
++    if blk0.operations:
++        if blk1.operations:
++            return cmp(blk0.operations[0].oploc, blk1.operations[0].oploc)
++        else:
++            return -1
++    else:
++        if blk1.operations:
++            return 1
++        else:
++            return 0
++
++def edge_comparator(edge0, edge1):
++    return block_comparator(edge0.target, edge1.target)
+ 
+ class FunctionGraph(object):
+     __slots__ = ['startblock', 'returnblock', 'exceptblock', '__dict__']
+@@ -94,6 +208,21 @@
+                 seen[block] = True
+                 stack += block.exits[::-1]
+ 
++    def iterblocks_by_source(self):
++        # Try to preserve logical source ordering in the blocks
++        block = self.startblock
++        yield block
++        seen = {block: True}
++        stack = list(block.exits[::-1])
++        stack.sort(edge_comparator)
++        while stack:
++            block = stack.pop().target
++            if block not in seen:
++                yield block
++                seen[block] = True
++                stack += block.exits[::-1]
++                stack.sort(edge_comparator)
++
+     def iterlinks(self):
+         block = self.startblock
+         seen = {block: True}
+@@ -183,14 +312,14 @@
+         self.exits      = []              # list of Link(s)
+ 
+     def at(self):
+-        if self.operations and self.operations[0].offset >= 0:
+-            return "@%d" % self.operations[0].offset
++        if self.operations:
++            return str(self.operations[0].oploc)
+         else:
+             return ""
+ 
+     def __str__(self):
+         if self.operations:
+-            txt = "block@%d" % self.operations[0].offset
++            txt = "block%s" % self.operations[0].oploc
+         else:
+             if (not self.exits) and len(self.inputargs) == 1:
+                 txt = "return block"
+@@ -245,6 +374,21 @@
+         from pypy.translator.tool.graphpage import try_show
+         try_show(self)
+ 
++    def isreturnblock(self):
++        return (not self.operations) and (not self.exits) and len(self.inputargs) == 1
++
++    def get_base_label(self, blocknum):
++        # Generate a more friendly C label for this block
++        if self.operations:
++            txt = "block"
++        elif (not self.exits) and len(self.inputargs) == 1:
++            txt = "return_block"
++        elif (not self.exits) and len(self.inputargs) == 2:
++            txt = "raise_block"
++        else:
++            txt = "codeless_block"
++        return '%s%d' % (txt, blocknum)
++
+ 
+ class Variable(object):
+     __slots__ = ["_name", "_nr", "concretetype"]
+@@ -331,13 +475,15 @@
+ 
+ 
+ class SpaceOperation(object):
+-    __slots__ = "opname args result offset".split()
++    __slots__ = "opname args result oploc".split()
+ 
+-    def __init__(self, opname, args, result, offset=-1):
++    def __init__(self, opname, args, result, oploc=None):
+         self.opname = intern(opname)      # operation name
+         self.args   = list(args)  # mixed list of var/const
+         self.result = result      # either Variable or Constant instance
+-        self.offset = offset      # offset in code string
++        if oploc is None:
++            oploc = OperationLoc([None])
++        self.oploc = oploc
+ 
+     def __eq__(self, other):
+         return (self.__class__ is other.__class__ and 
+@@ -352,8 +498,9 @@
+         return hash((self.opname,tuple(self.args),self.result))
+ 
+     def __repr__(self):
+-        return "%r = %s(%s)" % (self.result, self.opname,
+-                                ", ".join(map(repr, self.args)))
++        return "%r = %s(%s) (%s)" % (self.result, self.opname,
++                                     ", ".join(map(repr, self.args)),
++                                     self.oploc)
+ 
+ class Atom(object):
+     def __init__(self, name):
+@@ -448,8 +595,7 @@
+                 for op in oplist:
+                     copyop = SpaceOperation(op.opname,
+                                             [copyvar(v) for v in op.args],
+-                                            copyvar(op.result), op.offset)
+-                    #copyop.offset = op.offset
++                                            copyvar(op.result), op.oploc)
+                     result.append(copyop)
+                 return result
+             newblock.operations = copyoplist(block.operations)
+diff -r cd083843b67a pypy/objspace/flow/objspace.py
+--- a/pypy/objspace/flow/objspace.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/objspace/flow/objspace.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -310,7 +310,9 @@
+     def do_operation(self, name, *args_w):
+         spaceop = SpaceOperation(name, args_w, Variable())
+         if hasattr(self, 'executioncontext'):  # not here during bootstrapping
+-            spaceop.offset = self.executioncontext.crnt_offset
++            codeloc = CodeLoc(self.executioncontext.code,
++                              self.executioncontext.crnt_offset)
++            spaceop.oploc = OperationLoc([codeloc])
+             self.executioncontext.recorder.append(spaceop)
+         return spaceop.result
+ 
+diff -r cd083843b67a pypy/objspace/flow/test/test_model.py
+--- a/pypy/objspace/flow/test/test_model.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/objspace/flow/test/test_model.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -132,3 +132,25 @@
+     assert v2.renamed
+     assert v2.name.startswith("foobar_") and v2.name != v.name
+     assert v2.name.split('_', 1)[1].isdigit()
++
++def test_source_locations():
++    # Invent some random offsets into the code:
++    co = sample_function.__code__
++    codelocA = CodeLoc(co, 42)
++    codelocB = CodeLoc(co, 87)
++
++    assert str(codelocA) == 'sample_function@42'
++    assert str(codelocB) == 'sample_function@87'
++
++    assert cmp(codelocA, codelocB) < 0
++    assert cmp(codelocB, codelocA) > 0
++    
++    oplocA = OperationLoc([codelocA])
++    oplocB = OperationLoc([codelocB])
++
++    assert str(oplocA) == '[sample_function@42]'
++    assert str(oplocB) == '[sample_function@87]'
++
++    assert cmp(oplocA, oplocB) < 0
++    assert cmp(oplocB, oplocA) > 0
++
+diff -r cd083843b67a pypy/rpython/rtyper.py
+--- a/pypy/rpython/rtyper.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/rpython/rtyper.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -800,7 +800,7 @@
+         return vars
+ 
+     def genop(self, opname, args_v, resulttype=None):
+-        return self.llops.genop(opname, args_v, resulttype)
++        return self.llops.genop(opname, args_v, resulttype, self.spaceop.oploc)
+ 
+     def gendirectcall(self, ll_function, *args_v):
+         return self.llops.gendirectcall(ll_function, *args_v)
+@@ -935,7 +935,7 @@
+                                                     v.concretetype))
+         return v
+ 
+-    def genop(self, opname, args_v, resulttype=None):
++    def genop(self, opname, args_v, resulttype=None, oploc=None):
+         try:
+             for v in args_v:
+                 v.concretetype
+@@ -944,7 +944,7 @@
+                                  " and pass its result to genop(),"
+                                  " never hop.args_v directly.")
+         vresult = Variable()
+-        self.append(SpaceOperation(opname, args_v, vresult))
++        self.append(SpaceOperation(opname, args_v, vresult, oploc))
+         if resulttype is None:
+             vresult.concretetype = Void
+             return None
+diff -r cd083843b67a pypy/translator/backendopt/inline.py
+--- a/pypy/translator/backendopt/inline.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/translator/backendopt/inline.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -4,6 +4,7 @@
+ from pypy.translator.unsimplify import copyvar
+ from pypy.objspace.flow.model import Variable, Constant, Block, Link
+ from pypy.objspace.flow.model import SpaceOperation, c_last_exception
++from pypy.objspace.flow.model import OperationLoc
+ from pypy.objspace.flow.model import FunctionGraph
+ from pypy.objspace.flow.model import traverse, mkentrymap, checkgraph
+ from pypy.annotation import model as annmodel
+@@ -231,6 +232,7 @@
+         self.varmap = {}
+         self._copied_blocks = {}
+         self.op = block.operations[index_operation]
++        self.callsite_oploc = self.op.oploc
+         self.graph_to_inline = self.get_graph_from_op(self.op)
+         self.exception_guarded = False
+         if (block.exitswitch == c_last_exception and
+@@ -297,7 +299,9 @@
+         
+     def copy_operation(self, op):
+         args = [self.get_new_name(arg) for arg in op.args]
+-        result = SpaceOperation(op.opname, args, self.get_new_name(op.result))
++        new_oploc = OperationLoc(self.callsite_oploc.codelocs[:] + op.oploc.codelocs[:])
++        result = SpaceOperation(op.opname, args, self.get_new_name(op.result), 
++                                new_oploc)
+         return result
+ 
+     def copy_block(self, block):
+diff -r cd083843b67a pypy/translator/c/funcgen.py
+--- a/pypy/translator/c/funcgen.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/translator/c/funcgen.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -1,4 +1,6 @@
+ import sys
++import inspect
++import dis
+ from pypy.translator.c.support import USESLOTS # set to False if necessary while refactoring
+ from pypy.translator.c.support import cdecl
+ from pypy.translator.c.support import llvalue_from_constant, gen_assignments
+@@ -22,6 +24,38 @@
+ 
+ KEEP_INLINED_GRAPHS = False
+ 
++def block_comparator(blk0, blk1):
++    '''
++    Sort function for blocks, putting them in an ordering that attempts to
++    maximize readability of the generated C code
++    '''
++    # print 'comparing %r and %r' % (blk0, blk1)
++    # Put the start/end block at the top/bottom:
++    if blk0.isstartblock:
++        return -1
++
++    if blk1.isstartblock:
++        return 1
++
++    # Order blocks by the offset, where present:
++    if blk0.operations:
++        if blk1.operations:
++            return cmp(blk0.operations[0].oploc, blk1.operations[0].oploc)
++        else:
++            return -1
++    else:
++        if blk1.operations:
++            return 1
++        else:
++            return 0
++
++def escape_c_comments(py_src):
++    # Escape C comments within RPython source, to avoid generating bogus
++    # comments in our generated C source:
++    py_src = py_src.replace('/*', '')
++    py_src = py_src.replace('*/', '')
++    return py_src
++
+ class FunctionCodeGenerator(object):
+     """
+     Collects information about a function which we have to generate
+@@ -210,14 +244,57 @@
+ 
+     def cfunction_body(self):
+         graph = self.graph
+-        yield 'goto block0;'    # to avoid a warning "this label is not used"
++        # Try to print python source code:
++        if hasattr(graph, 'func'):
++            filename = inspect.getfile(graph.func)
++            #yield '/* name: %r */' % filename
++            try:
++                src, startline = inspect.getsourcelines(graph.func)
++            except IOError:
++                pass # No source found
++            except IndexError:
++                pass # Bulletproofing
++            else:
++                yield '/* Python source %r' % filename
++                for i, line in enumerate(src):
++                    line = line.rstrip()
++                    line = escape_c_comments(line)
++                    # FuncNode.funcgen_implementation treats lines ending in ':'
++                    # as C blocks, which messes up the formatting.
++                    # Work around this:
++                    if line.endswith(':'):
++                        line += ' '
++                    yield ' * %4d : %s' % (startline + i, line)
++                yield ' */'
++
++        label = graph.startblock.get_base_label(self.blocknum[graph.startblock])
++        yield 'goto %s;' % label # to avoid a warning "this label is not used"
++
++        # Sort the blocks into a (hopefully) readable order:
++        blocks = list(graph.iterblocks_by_source())
++        blocks.sort(block_comparator)
+ 
+         # generate the body of each block
+-        for block in graph.iterblocks():
++        for block in blocks:
++            cursrcloc = None
+             myblocknum = self.blocknum[block]
+             yield ''
+-            yield 'block%d:' % myblocknum
++            yield '%s:' % block.get_base_label(myblocknum)
++            #yield "/* repr(block): %r */" % (block, )
++            #yield "/* type(block): %r */" % (type(block), )
+             for i, op in enumerate(block.operations):
++                #yield "/* type(op): %r */" % (type(op), )
++                #yield "/* op.oploc: %s */" % (op.oploc, )
++                codeloc = op.oploc.codelocs[-1]
++                if codeloc:
++                    srcloc = codeloc.get_source_loc()
++                    if srcloc != cursrcloc:
++                        try:
++                            yield "/* %s:%d : %s */" % (codeloc.code.co_name, srcloc.linenum, escape_c_comments(srcloc.get_text()))
++                            cursrcloc = srcloc
++                        except IOError:
++                            pass
++
+                 for line in self.gen_op(op):
+                     yield line
+             if len(block.exits) == 0:
+@@ -310,7 +387,7 @@
+             assignments.append((a2typename, dest, src))
+         for line in gen_assignments(assignments):
+             yield line
+-        label = 'block%d' % self.blocknum[link.target]
++        label = link.target.get_base_label(self.blocknum[link.target])
+         if link.target in self.innerloops:
+             loop = self.innerloops[link.target]
+             if link is loop.links[-1]:   # link that ends a loop
+diff -r cd083843b67a pypy/translator/c/test/test_genc.py
+--- a/pypy/translator/c/test/test_genc.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/translator/c/test/test_genc.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -1,4 +1,5 @@
+ import autopath, sys, os, py
++import re
+ from pypy.rpython.lltypesystem.lltype import *
+ from pypy.annotation import model as annmodel
+ from pypy.translator.translator import TranslationContext
+@@ -498,3 +499,130 @@
+     else:
+         assert 0, "the call was not found in the C source"
+     assert 'PYPY_INHIBIT_TAIL_CALL();' in lines[i+1]
++
++def get_generated_c_source(fn, types):
++    # Return a (optimized fn, c source code, c source filename) 3-tuple
++    t = Translation(fn)
++    t.annotate(types)
++    c_filename_path = t.source_c()
++    h = c_filename_path.open()
++    src = h.read()
++    h.close()
++    c_fn = t.compile_c()
++    return (c_fn, src, c_filename_path)
++
++def extract_c_function(c_src, fname):
++    # Extract the source for a given C function out of a the given src string
++    # Makes assumptions about the layout of the source
++    pattern = '^(.+) \**%s\(.*\) {$' % fname
++    within_fn = False
++    result = ''
++    for line in c_src.splitlines():
++        if within_fn:
++            result += line + '\n'
++            if line.startswith('}'):
++                return result
++        else:
++            m = re.match(pattern, line)
++            if m:
++                within_fn = True
++                result += line + '\n'
++    return result
++    
++    
++
++def test_generated_c_source():
++    # Verify that generate C source "looks good"
++    # We'll use is_perfect_number, as it contains a loop and a conditional
++
++    # Generate C source code
++    from pypy.translator.test.snippet import is_perfect_number
++    c_fn, c_src, c_filename_path = get_generated_c_source(is_perfect_number,
++                                                        [int])
++
++    # Locate the C source for the type-specialized function:
++    c_fn_src = extract_c_function(c_src, 'pypy_g_is_perfect_number')
++    
++    # Verify that the C source contains embedded comments containing the lines
++    # of the python source:
++    expected_comment_lines = [
++        '/* is_perfect_number:31 :     while div < n: */',
++        '/* is_perfect_number:32 :         if n % div == 0: */',
++        '/* is_perfect_number:33 :             sum += div */',
++        '/* is_perfect_number:34 :         div += 1 */',
++        '/* is_perfect_number:35 :     return n == sum */']
++    for exp_line in expected_comment_lines:
++        assert exp_line in c_fn_src
++        
++    # Verify that the lines occur in the correct order
++    # ...we do this by filtering the function's generated C source to just
++    # those lines containing our comments (and dropping whitespace):
++    lines = c_fn_src.splitlines()
++    lines = [line.strip()
++             for line in lines
++             if '/* is_perfect_number:' in line]
++
++    # ...we should now have exact equality: the ordering should be as expected,
++    # and each comment should appear exactly once:
++    assert lines == expected_comment_lines
++
++    # Ensure that the generated C function does the right thing:
++    assert c_fn(5) == False
++    assert c_fn(6) == True
++    assert c_fn(7) == False
++
++    assert c_fn(5.0) == False
++    assert c_fn(6.0) == True
++    assert c_fn(7.0) == False
++
++    assert c_fn(5L) == False
++    assert c_fn(6L) == True
++    assert c_fn(7L) == False
++
++    try:
++        c_fn('hello world')
++    except:
++        pass
++    else:
++        raise 'Was expected exception'
++    
++def test_escaping_c_comments():
++    # Ensure that c comments within RPython code get escaped when we generate
++    # our .c code (to avoid generating bogus C)
++    # See e.g. pypy.module.cpyext.dictobject's PyDict_Next, which has a
++    # docstring embedding a C comment
++    def c_style_comment(a, b):
++        '''Here is a C-style comment within an RPython docstring:
++                /* hello world */
++        '''
++        # and here's one in a string literal:
++        return '/* hello world a:%s b:%s */' % (a, b)
++
++    def cplusplus_style_comment(a, b):
++        '''Here is a C++-style comment within an RPython docstring:
++                // hello world
++        '''
++        # and here are some in string literals, and one as the floor division
++        # operator:
++        return '// hello world: a // b = %s' % (a // b)
++
++    for fn_name, exp_output in [('c_style_comment',
++                                 '/* hello world a:6 b:3 */'),
++                                ('cplusplus_style_comment',
++                                 '// hello world: a // b = 2')]:
++        fn = locals()[fn_name]
++
++        c_fn, c_src, c_filename_path = get_generated_c_source(fn, [int, int])
++        # If the above survived, then the C compiler managed to handle
++        # the generated C code
++
++        # Verify that the generated code works (i.e. that we didn't
++        # accidentally change the meaning):
++        assert c_fn(6, 3) == exp_output
++
++        # Ensure that at least part of the docstrings made it into the C
++        # code:
++        c_fn_src = extract_c_function(c_src, 'pypy_g_' + fn_name)
++        assert 'Here is a ' in c_fn_src
++        assert 'style comment within an RPython docstring' in c_fn_src
++        
+diff -r cd083843b67a pypy/translator/driver.py
+--- a/pypy/translator/driver.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/translator/driver.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -539,6 +539,7 @@
+             dstname = self.compute_exe_name() + '.staticdata.info'
+             shutil.copy(str(fname), str(dstname))
+             self.log.info('Static data info written to %s' % dstname)
++        return c_source_filename
+ 
+     #
+     task_source_c = taskdef(task_source_c, ['database_c'], "Generating c source")
+diff -r cd083843b67a pypy/translator/gensupp.py
+--- a/pypy/translator/gensupp.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/translator/gensupp.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -16,8 +16,8 @@
+     def visit(block):
+         if isinstance(block, Block):
+             # first we order by offset in the code string
+-            if block.operations:
+-                ofs = block.operations[0].offset
++            if block.operations and block.operations[0].oploc.codelocs[0]:
++                ofs = block.operations[0].oploc.codelocs[0].offset
+             else:
+                 ofs = sys.maxint
+             # then we order by input variable name or value
+diff -r cd083843b67a pypy/translator/interactive.py
+--- a/pypy/translator/interactive.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/translator/interactive.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -138,7 +138,7 @@
+     def source_c(self, argtypes=None, **kwds):
+         self.update_options(argtypes, kwds)
+         self.ensure_backend('c')
+-        self.driver.source_c()
++        return self.driver.source_c()
+ 
+     def source_cl(self, argtypes=None, **kwds):
+         self.update_options(argtypes, kwds)
+diff -r cd083843b67a pypy/translator/llsupport/wrapper.py
+--- a/pypy/translator/llsupport/wrapper.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/translator/llsupport/wrapper.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -59,6 +59,8 @@
+     # "return result"
+     block = Block(wrapper_inputargs)
+     wgraph = FunctionGraph('pyfn_' + (newname or func.func_name), block)
++    if hasattr(graph, 'func'):
++        wgraph.func = graph.func
+     translator.update_call_graph(wgraph, graph, object())
+     translator.graphs.append(wgraph)
+     block.operations[:] = newops
+diff -r cd083843b67a pypy/translator/simplify.py
+--- a/pypy/translator/simplify.py	Mon Dec 20 17:17:45 2010 +0100
++++ b/pypy/translator/simplify.py	Wed Jan 05 16:14:35 2011 -0500
+@@ -294,7 +294,7 @@
+                 return renaming.get(v, v)
+             def rename_op(op):
+                 args = [rename(a) for a in op.args]
+-                op = SpaceOperation(op.opname, args, rename(op.result), op.offset)
++                op = SpaceOperation(op.opname, args, rename(op.result), op.oploc)
+                 # special case...
+                 if op.opname == 'indirect_call':
+                     if isinstance(op.args[0], Constant):

pypy.spec

@@ -1,6 +1,6 @@
 Name:           pypy
 Version:        1.4.1
-Release:        3%{?dist}
+Release:        4%{?dist}
 Summary:        Python implementation with a Just-In-Time compiler
 
 Group:          Development/Languages
@@ -136,9 +136,33 @@ Patch2: fix-test_commands-expected-ls-output-issue7108.patch
 #   https://codespeak.net/issue/pypy-dev/issue614
 Patch3: pypy-1.4.1-add-LIBRARY_INSTALLATION_PATH.patch
 
+# Try to improve the readability of the generated .c code, by adding in the
+# RPython source as comments where possible.
+# A version of this was sent upstream as:
+#  http://codespeak.net/pipermail/pypy-dev/2010q4/006532.html
+# TODO: get this into the upstream bug tracker, and finish inlining
+# support (rhbz#666963)
+Patch4: pypy-1.4.1-more-readable-c-code.patch
+
+
 # Build-time requirements:
 
-BuildRequires:  python-devel
+# pypy's can be rebuilt using itself, rather than with CPython; doing so
+# halves the build time.
+#
+# Turn it off with this boolean, to revert back to rebuilding using CPython
+# and avoid a cycle in the build-time dependency graph:
+#
+%global use_self_when_building 1
+%if 0%{use_self_when_building}
+BuildRequires: pypy
+%global bootstrap_python_interp pypy
+%else
+BuildRequires: python-devel
+%global bootstrap_python_interp python
+%endif
+
+
 
 # FIXME: I'm seeing errors like this in the logs:
 #   [translation:WARNING] The module '_rawffi' is disabled
@@ -215,6 +239,8 @@ sed -i \
   -e 's|LIBRARY_INSTALLATION_PATH|"%{pypyprefix}"|' \
   pypy/translator/goal/app_main.py
 
+%patch4 -p1 -b .more-readable-c-code
+
 
 # Replace /usr/local/bin/python shebangs with /usr/bin/python:
 find -name "*.py" -exec \
@@ -304,6 +330,7 @@ BuildPyPy() {
   # doesn't interract well with the results of using our standard build flags.
   # For now, filter our CFLAGS of everything that could be conflicting with
   # pypy.  Need to check these and reenable ones that are okay later.
+  # Filed as https://bugzilla.redhat.com/show_bug.cgi?id=666966
   export CFLAGS=$(echo "$RPM_OPT_FLAGS" | sed -e 's/-Wp,-D_FORTIFY_SOURCE=2//' -e 's/-fexceptions//' -e 's/-fstack-protector//' -e 's/--param=ssp-buffer-size=4//' -e 's/-O2//' -e 's/-fasynchronous-unwind-tables//' -e 's/-march=i686//' -e 's/-mtune=atom//')
 
   # If we're already built the JIT-enabled "pypy", then use it for subsequent
@@ -311,7 +338,10 @@ BuildPyPy() {
   if test -x './pypy' ; then
     INTERP='./pypy'
   else
-    INTERP='python'
+    # First pypy build within this rpm build?
+    # Fall back to using the bootstrap python interpreter, which might be a
+    # system copy of pypy from an earlier rpm, or be cpython's /usr/bin/python:
+    INTERP='%{bootstrap_python_interp}'
   fi
 
   # Here's where we actually invoke the build:
@@ -484,6 +514,34 @@ mkdir -p %{buildroot}/%{pypyprefix}/site-packages
   %{buildroot}/%{_bindir}/pypy \
   0
 
+# Capture the RPython source code files from the build within the debuginfo
+# package (rhbz#666975)
+%global pypy_debuginfo_dir /usr/src/debug/pypy-%{version}-src
+mkdir -p %{buildroot}%{pypy_debuginfo_dir}
+
+# copy over everything:
+cp -a pypy %{buildroot}%{pypy_debuginfo_dir}
+
+# ...then delete files that aren't .py files:
+find \
+  %{buildroot}%{pypy_debuginfo_dir} \
+  \( -type f                        \
+     -a                             \
+     \! -name "*.py"                \
+  \)                                \
+  -delete
+
+# We don't need bytecode for these files; they are being included for reference
+# purposes.
+# There are some rpmlint warnings from these files:
+#   non-executable-script
+#   wrong-script-interpreter
+#   zero-length
+#   script-without-shebang
+#   dangling-symlink
+# but given that the objective is to preserve a copy of the source code, those
+# are acceptable.
+
 %check
 topdir=$(pwd)
 
@@ -511,6 +569,7 @@ CheckPyPy() {
 
     # Gather a list of tests to skip, due to known failures
     # TODO: report these failures to pypy upstream
+    # See also rhbz#666967 and rhbz#666969
     TESTS_TO_SKIP=""
 
     # Test failures relating to missing codecs
@@ -622,6 +681,14 @@ CheckPyPy() {
       #     AssertionError: ValueError not raised
       SkipTest test_zlib
 
+    %if 0%{use_self_when_building}
+    # Patch 3 prioritizes the installed copy of pypy's libraries over the
+    # build copy.
+    # This leads to test failures of test_pep263 and test_tarfile
+    # For now, suppress these when building using pypy itself:
+    SkipTest test_pep263   # on-disk encoding issues
+    SkipTest test_tarfile  # permissions issues
+    %endif
 
     # Run the built binary through the selftests:
     time ./$ExeName -m test.regrtest -x $TESTS_TO_SKIP
@@ -696,6 +763,14 @@ rm -rf $RPM_BUILD_ROOT
 
 
 %changelog
+* Wed Jan  5 2011 David Malcolm <dmalcolm@redhat.com> - 1.4.1-4
+- rebuild pypy using itself, for speed, with a boolean to break this cycle in
+the build-requirement graph (falling back to using "python-devel" aka CPython)
+- add work-in-progress patch to try to make generated c more readable
+(rhbz#666963)
+- capture the RPython source code files from the build within the debuginfo
+package (rhbz#666975)
+
 * Wed Dec 22 2010 David Malcolm <dmalcolm@redhat.com> - 1.4.1-3
 - try to respect the FHS by installing libraries below libdir, rather than
 datadir; patch app_main.py to look in this installation location first when