[pypy-svn] r25561 - pypy/branch/stacklesscfg/pypy/translator/backendopt

[mwh at codespeak.net]

Author: mwh
Date: Sat Apr  8 17:49:56 2006
New Revision: 25561

Modified:
   pypy/branch/stacklesscfg/pypy/translator/backendopt/support.py
Log:
merging of http://codespeak.net/svn/pypy/dist/pypy/translator/backendopt/support.py
revisions 25473 to 25557:

    ------------------------------------------------------------------------
    r25555 | hpk | 2006-04-08 17:32:31 +0200 (Sat, 08 Apr 2006) | 2 lines
    
    merge r25548 of stacklesscfg branch (split_block returns splitlink instead of afterblock)
    
    ------------------------------------------------------------------------
    r25530 | cfbolz | 2006-04-07 23:49:27 +0200 (Fri, 07 Apr 2006) | 2 lines
    
    move find_backedges etc to support
    
    ------------------------------------------------------------------------
    r25523 | cfbolz | 2006-04-07 20:42:39 +0200 (Fri, 07 Apr 2006) | 5 lines
    
    (pedronis, cfbolz):
    
    do the (very indeterministic) stack check insertion as late as possible, just
    before code generation.
    
    ------------------------------------------------------------------------


Modified: pypy/branch/stacklesscfg/pypy/translator/backendopt/support.py
==============================================================================
--- pypy/branch/stacklesscfg/pypy/translator/backendopt/support.py	(original)
+++ pypy/branch/stacklesscfg/pypy/translator/backendopt/support.py	Sat Apr  8 17:49:56 2006
@@ -1,7 +1,9 @@
 import py
 from pypy.rpython.lltypesystem import lltype
+from pypy.translator.simplify import get_graph
 from pypy.rpython.rmodel import inputconst 
 from pypy.tool.ansi_print import ansi_log
+from pypy.annotation.model import setunion
 from pypy.translator.unsimplify import split_block, copyvar, insert_empty_block
 from pypy.objspace.flow.model import Constant, Variable, SpaceOperation, c_last_exception
 from pypy.rpython.lltypesystem import lltype
@@ -95,6 +97,78 @@
         afterblock.operations.extend(generate_keepalive(keep_alive_vars))
     return splitlink
 
+def calculate_call_graph(translator):
+    calls = {}
+    for graph in translator.graphs:
+        if getattr(getattr(graph, "func", None), "suggested_primitive", False):
+            continue
+        calls[graph] = {}
+        for block in graph.iterblocks():
+            for op in block.operations:
+                if op.opname == "direct_call":
+                    called_graph = get_graph(op.args[0], translator)
+                    if called_graph is not None:
+                        calls[graph][called_graph] = block
+                if op.opname == "indirect_call":
+                    graphs = op.args[-1].value
+                    if graphs is not None:
+                        for called_graph in graphs:
+                            calls[graph][called_graph] = block
+    return calls
+
+def find_backedges(graph):
+    """finds the backedges in the flow graph"""
+    scheduled = [graph.startblock]
+    seen = {}
+    backedges = []
+    while scheduled:
+        current = scheduled.pop()
+        seen[current] = True
+        for link in current.exits:
+            if link.target in seen:
+                backedges.append(link)
+            else:
+                scheduled.append(link.target)
+    return backedges
+
+def compute_reachability(graph):
+    reachable = {}
+    for block in graph.iterblocks():
+        reach = {}
+        scheduled = [block]
+        while scheduled:
+            current = scheduled.pop()
+            for link in current.exits:
+                if link.target in reachable:
+                    reach = setunion(reach, reachable[link.target])
+                    continue
+                if link.target not in reach:
+                    reach[link.target] = True
+        reachable[block] = reach
+    return reachable
+
+def find_loop_blocks(graph):
+    """find the blocks in a graph that are part of a loop"""
+    loop = {}
+    reachable = compute_reachability(graph)
+    for backedge in find_backedges(graph):
+        start = backedge.target
+        end = backedge.prevblock
+        loop[start] = start
+        loop[end] = start
+        scheduled = [start]
+        seen = {}
+        while scheduled:
+            current = scheduled.pop()
+            connects = end in reachable[current]
+            seen[current] = True
+            if connects:
+                loop[current] = start
+            for link in current.exits:
+                if link.target not in seen:
+                    scheduled.append(link.target)
+    return loop
+
 def md5digest(translator):
     import md5
     m = md5.new()