laser 0.7.0.pre1

data/lib/laser/third_party/rgl/control_flow.rb

@@ -0,0 +1,170 @@
+require 'laser/third_party/rgl/mutable'
+require 'set'
+
+module RGL
+  # This is an implementation of a more efficient graph customized
+  # for control-flow purposes. Lots of operations on RGL's base library,
+  # while re-using a lot of code, are needlessly algorithmically insufficient.
+  # (#empty is O(|V|)!)
+  class ControlFlowGraph    
+    EDGE_NORMAL = 1 << 0
+    EDGE_ABNORMAL = 1 << 1
+    EDGE_FAKE = 1 << 2
+    EDGE_EXECUTABLE = 1 << 3
+    EDGE_BLOCK_TAKEN = 1 << 4
+
+    include Enumerable
+    include MutableGraph
+    attr_reader :enter, :exit
+    attr_reader :vertices, :vertex_lookup
+    
+    def initialize
+      @enter = Laser::Analysis::ControlFlow::TerminalBasicBlock.new('Enter')
+      @exit = Laser::Analysis::ControlFlow::TerminalBasicBlock.new('Exit')
+      @vertices = Set[@enter, @exit]
+      @vertex_lookup = {'Enter' => @enter, 'Exit' => @exit}
+    end
+    
+    def [](key)
+      vertex_with_name(key.name)
+    end
+    
+    def vertex_with_name(key)
+      @vertex_lookup[key]
+    end
+
+    # Gets all the edges. O(E).
+    def edges
+      vertices.map { |vert| vert.successors.map { |succ| [vert, succ] }}.flatten 1
+    end
+    
+    # Enumerates the vertices. O(V).
+    def each_vertex(&b)
+      vertices.each(&b)
+    end
+    alias each each_vertex
+
+    # Enumerates every vertex adjacent to u. O(V).
+    def each_adjacent(u, &b)
+      self[u].successors.each(&b)
+    end
+    
+    # Jacked from RGL. O(E).
+    def each_edge
+      each_vertex { |u|
+        each_adjacent(u) { |v| yield u,v }
+      }
+    end
+    
+    # Adds the vertex to the set of vertices. O(1) amortized.
+    def add_vertex(u)
+      @vertex_lookup[u.name] = u
+      vertices << u
+    end
+    
+    # Adds the edge to the graph. O(1) amortized.
+    def add_edge(u, v, flags = EDGE_NORMAL)
+      u.join(v)
+      u.set_flag(v, flags)
+    end
+
+    def is_block_taken?(src, dest)
+      src.has_flag?(dest, EDGE_BLOCK_TAKEN)
+    end
+
+    def is_abnormal?(src, dest)
+      src.has_flag?(dest, EDGE_ABNORMAL)
+    end
+    
+    def is_fake?(src, dest)
+      src.has_flag?(dest, EDGE_FAKE)
+    end
+    
+    def is_executable?(src, dest)
+      src.has_flag?(dest, EDGE_EXECUTABLE)
+    end
+    
+    def add_flag(src, dest, flag)
+      src.add_flag(dest, flag)
+    end
+    
+    def remove_flag(src, dest, flag)
+      src.remove_flag(dest, flag)
+    end
+
+    # Removes the vertex from the graph. O(E) amortized.
+    def remove_vertex(u)
+      u.clear_edges
+      looked_up = self[u]
+      # looked_up.successors.each do |succ|
+      #   self[succ].remove_predecessor looked_up
+      #   self[looked_up].delete_all_flags succ
+      # end
+      # looked_up.predecessors.each do |pred|
+      #   self[pred].remove_successor looked_up
+      #   self[pred].delete_all_flags looked_up
+      # end
+      @vertex_lookup.delete looked_up.name
+      vertices.delete looked_up
+    end
+    
+    # Removes the edge from the graph. O(1) amortized.
+    def remove_edge(u, v)
+      
+      looked_up_u, looked_up_v = self[u], self[v]
+      looked_up_u.disconnect(looked_up_v)
+      # looked_up_u.remove_successor looked_up_v
+      # looked_up_v.remove_predecessor looked_up_u
+    end
+    
+    # Counts the number of vertices. O(1).
+    def num_vertices
+      vertices.size
+    end
+    alias size num_vertices
+    
+    # Does the graph have no vertices? O(1).
+    def empty?
+      vertices.empty?
+    end
+    
+    # Does the graph contain this vertex? O(1).
+    def has_vertex?(u)
+      vertices.include?(u)
+    end
+    
+    def has_edge?(u, v)
+      self[u].successors.include?(v)
+    end
+    
+    # Returns an array of vertices in this graph. O(V).
+    def to_a
+      vertices.to_a
+    end
+    
+    # Is the graph directed? Yes, always.
+    def directed?
+      true
+    end
+    
+    # Computes the total degree of the vertex. O(1).
+    def degree(u)
+      in_degree(u) + out_degree(u)
+    end
+    
+    # What is the in-degree of the vertex u? O(1).
+    def in_degree(u)
+      self[u].predecessors.size
+    end
+
+    # What is the out-degree of the vertex u? O(1).
+    def out_degree(u)
+      self[u].successors.size
+    end
+    
+    # How many edges are in the graph? O(V).
+    def num_edges
+      vertices.map { vertices.successors.size }.inject(:+)
+    end
+  end
+end

data/lib/laser/third_party/rgl/depth_first_spanning_tree.rb

@@ -0,0 +1,37 @@
+
+# connected_components.rb
+#
+# This file contains the algorithms for the connected components of an
+# undirected graph (each_connected_component) and strongly connected components
+# for directed graphs (strongly_connected_components).
+#
+require 'set'
+require 'laser/third_party/rgl/traversal'
+
+module RGL
+  module Graph
+    # Computes the depth first spanning tree of the CFG, and
+    # also attaches the depth-first ordering to the basic blocks
+    # in the CFG.
+    # O(|V| + |E|), just like DFS.
+    def depth_first_spanning_tree(start_node)
+      raise ArgumentError unless vertices.include?(start_node)
+      tree = DirectedAdjacencyGraph.new
+      visited = Set.new
+      build_dfst(tree, start_node, visited)
+      tree
+    end
+    
+    # builds the dfst from the start node.
+    # O(|V| + |E|), just like DFS.
+    def build_dfst(tree, node, visited)
+      visited << node
+      node.real_successors.each do |other|
+        if !visited.include?(other)
+          tree.add_edge(node, other)
+          build_dfst(tree, other, visited)
+        end
+      end
+    end
+  end
+end

data/lib/laser/third_party/rgl/dominators.rb

@@ -0,0 +1,124 @@
+# dominators.rb
+#
+# This file contains algorithms for finding the dominators and dominance
+# frontier of a control flow graph. These algorithms require that every node
+# be reachable from the start node. Keep this in mind.
+require 'set'
+require 'laser/third_party/rgl/traversal'
+
+module RGL
+  module Graph
+    # Returns the dominator tree of the graph. O(V^2), but performs better than
+    # or close to Lengauer-Tarjan on real-world ASTs.
+    #
+    # If the start node is not provided, it is assumed the receiver is a
+    # ControlFlowGraph and has an #enter method.
+    def dominator_tree(start_node = self.enter)
+      doms = {start_node => start_node}
+      changed = true
+      reverse_postorder = compute_post_order(self, start_node)
+      while changed
+        changed = false
+        reverse_postorder.each do |b|
+          if (original = b.each_real_predecessors.find { |node| doms[node] })
+            new_idom = original
+            b.each_real_predecessors do |p|
+              if doms[p] && p != original
+                new_idom = dominator_set_intersect(p, new_idom, doms)
+              end
+            end
+            if doms[b] != new_idom
+              doms[b] = new_idom
+              changed = true
+            end
+          end
+        end
+      end
+
+      # doms is IDOM. All outward edges connect an IDom to its dominee.
+      d_tree = self.class.new
+      (vertices - [enter, exit]).each do |b|
+        copy = Laser::Analysis::ControlFlow::BasicBlock.new(b.name)
+        copy.instructions = b.instructions
+        d_tree.add_vertex(copy)
+      end
+      doms.each { |src, dest| d_tree.add_edge(d_tree[src], d_tree[dest]) unless src == enter && dest == enter }
+      d_tree
+    end
+
+    # Returns the dominance frontier of the graph.
+    #
+    # If the start node is not provided, it is assumed the receiver is a
+    # ControlFlowGraph and has an #enter method.
+    #
+    # return: Node => Set<Node>
+    def dominance_frontier(start_node = self.enter, dom_tree)
+      vertices.inject(Hash.new { |h, k| h[k] = Set.new }) do |result, b|
+        preds = b.real_predecessors
+        if preds.size >= 2
+          preds.each do |p|
+            b_dominator = dom_tree[b].successors.first
+            break unless b_dominator
+            runner = dom_tree[p]
+            while runner && runner != b_dominator
+              result[runner] << b
+              runner = runner.successors.first
+            end
+          end
+        end
+        result
+      end
+    end
+    
+    # Computes DF^+: the iterated dominance frontier of a set of blocks.
+    # Used in SSA conversion.
+    def iterated_dominance_frontier(set, dom_tree)
+      worklist = Set.new(set)
+      result = Set.new(set)
+      frontier = dominance_frontier(dom_tree)
+
+      until worklist.empty?
+        block = worklist.pop
+        frontier[dom_tree[block]].each do |candidate|
+          candidate_in_full_graph = self[candidate]
+          unless result.include?(candidate_in_full_graph)
+            result << candidate_in_full_graph
+            worklist << candidate_in_full_graph
+          end
+        end
+      end
+      result
+    end
+
+   private
+
+    # performs a set intersection of the dominator tree.
+    def dominator_set_intersect(b1, b2, doms)
+      finger1, finger2 = b1, b2
+      while finger1.post_order_number != finger2.post_order_number
+        finger1 = doms[finger1] while finger1.post_order_number < finger2.post_order_number
+        finger2 = doms[finger2] while finger2.post_order_number < finger1.post_order_number
+      end
+      finger1
+    end
+    
+    # Good idea: depth-first ordering. found some slides about it:
+    # http://pages.cs.wisc.edu/~fischer/cs701.f08/lectures/Lecture18.4up.pdf
+    def compute_post_order(graph, start_node)
+      i = 1
+      result = []
+      visited = Set.new
+      post_order_df = proc do |node|
+        visited << node
+        node.real_successors.each do |successor|
+          post_order_df.call(successor) unless visited.include?(successor)
+        end
+        result << node
+        node.post_order_number = i
+        i += 1
+      end
+      post_order_df.call(start_node)
+      result
+    end
+  end
+end

data/lib/laser/third_party/rgl/dot.rb

@@ -0,0 +1,93 @@
+# dot.rb
+#
+# $Id: dot.rb,v 1.8 2008/08/26 20:07:09 javanthropus Exp $
+#
+# Minimal Dot support, based on Dave Thomas's dot module (included in rdoc).
+# rdot.rb is a modified version which also contains support for undirected
+# graphs.
+
+require 'laser/third_party/rgl/rdot'
+
+module RGL
+
+  module Graph
+
+    # Return a RGL::DOT::Digraph for directed graphs or a DOT::Subgraph for an
+    # undirected Graph.  _params_ can contain any graph property specified in
+    # rdot.rb.
+
+    def to_dot_graph (params = {})
+      params['name'] ||= self.class.name.gsub(/:/,'_')
+      fontsize   = params['fontsize'] || '8'
+      fontname   = params['fontname'] || 'Times-Roman'
+      graph      = (directed? ? DOT::Digraph : DOT::Subgraph).new(params)
+      edge_class = directed? ? DOT::DirectedEdge : DOT::Edge
+      shape = params['shape'] || 'ellipse'
+      each_vertex do |v|
+        name = v.to_s
+        graph << DOT::Node.new('name'     => name,
+                               'fontsize' => fontsize,
+                               'label'    => name,
+                               'shape'    => shape,
+                               'fontname' => fontname)
+      end
+      each_edge do |u,v|
+        if respond_to?(:is_abnormal?)
+          if is_abnormal?(u, v) && is_block_taken?(u, v)
+            color = 'blue'
+          elsif is_abnormal?(u, v)
+            color = 'red'
+          elsif is_fake?(u, v)
+            color = '#bbbbbb'
+          else
+            color = 'black'
+          end
+          style = (is_fake?(u, v) || !is_executable?(u, v)) ? 'dashed' : 'solid'
+        else
+          color = 'black'
+          style = 'solid'
+        end
+        graph << edge_class.new('from'     => u.to_s,
+                                'to'       => v.to_s,
+                                'fontsize' => fontsize,
+                                'fontname' => fontname,
+                                'color'    => color,
+                                'style'    => style)
+      end
+      graph
+    end
+
+    # Output the DOT-graph to stream _s_.
+
+    def print_dotted_on (params = {}, s = $stdout)
+      s << to_dot_graph(params).to_s << "\n"
+    end
+
+    # Call dotty[http://www.graphviz.org] for the graph which is written to the
+    # file 'graph.dot' in the # current directory.
+
+    def dotty (params = {})
+      dotfile = "graph.dot"
+      File.open(dotfile, "w") {|f|
+        print_dotted_on(params, f)
+      }
+      system("dotty", dotfile)
+    end
+
+    # Use dot[http://www.graphviz.org] to create a graphical representation of
+    # the graph.  Returns the filename of the graphics file.
+
+    def write_to_graphic_file (fmt='png', dotfile='graph', params = {})
+      src = dotfile + ".dot"
+      dot = dotfile + "." + fmt
+
+      File.open(src, 'w') do |f|
+        f << self.to_dot_graph(params).to_s << "\n"
+      end
+
+      system( "dot -T#{fmt} -o #{dot} #{src}" )
+      dot
+    end
+
+  end                           # module Graph
+end                             # module RGL

data/lib/laser/third_party/rgl/graphxml.rb

@@ -0,0 +1,51 @@
+# graphxml.rb
+#
+# This file contains minimal support for creating RGL graphs from the GraphML
+# format (see http://www.graphdrawing.org/graphml).  The main purpose is to
+# have a rich set of example graphs to have some more tests.
+#
+# See the examples directory, which contains a subdirectory _north_ with the
+# Graph catalog GraphViz (see
+# http://www.research.att.com/sw/tools/graphviz/refs.html).
+#
+# We use REXML::StreamListener from the REXML library
+# (http://www.germane-software.com/software/rexml) to parse the grapml files.
+
+require 'laser/third_party/rgl/mutable'
+require 'rexml/document'
+require 'rexml/streamlistener'
+
+module RGL
+  module MutableGraph
+    # Used to parse a subset of GraphML into an RGL graph implementation.
+    class MutableGraphParser
+      include REXML::StreamListener
+
+      # First resets +graph+ to be empty and stores a reference for use with
+      # #tag_start.
+      def initialize (graph)
+        @graph = graph
+        @graph.remove_vertices(@graph.vertices)
+      end
+
+      # Processes incoming edge and node elements from GraphML in order to
+      # populate the graph given to #new.
+      def tag_start (name, attrs)
+        case name
+        when 'edge'
+          @graph.add_edge(attrs['source'], attrs['target'])
+        when 'node'
+          @graph.add_vertex(attrs['id'])
+        end
+      end
+    end		# class MutableGraphParser
+
+    # Initializes an RGL graph from a subset of the GraphML format given in
+    # +source+ (see http://www.graphdrawing.org/graphml).
+    def from_graphxml(source)
+      listener = MutableGraphParser.new(self)
+      REXML::Document.parse_stream(source, listener)
+      self
+    end
+  end                           # module MutableGraph
+end                             # module RGL