Properly use disassembler for DFG

Author: kddnewton

lib/syntax_tree/yarv/control_flow_graph.rb

@@ -34,8 +34,7 @@ def initialize(iseq, insns, blocks)
 
       def disasm
         fmt = Disassembler.new(iseq)
-        fmt.output.print("== cfg: #<ISeq:#{iseq.name}@<compiled>:1 ")
-        fmt.output.puts("(#{iseq.line},0)-(#{iseq.line},0)>")
+        fmt.output.puts("== cfg: #{iseq.inspect}")
 
         blocks.each do |block|
           fmt.output.puts(block.id)

lib/syntax_tree/yarv/data_flow_graph.rb

@@ -27,56 +27,48 @@ def initialize(cfg, insn_flows, block_flows)
       end
 
       def disasm
-        fmt = Disassembler.new
-        output = StringIO.new
-        output.puts "== dfg #{cfg.iseq.name}"
+        fmt = Disassembler.new(cfg.iseq)
+        fmt.output.puts("== dfg: #{cfg.iseq.inspect}")
 
         cfg.blocks.each do |block|
-          output.print(block.id)
-          unless block.incoming_blocks.empty?
-            srcs = block.incoming_blocks.map(&:id)
-            output.print(" # from: #{srcs.join(", ")}")
-          end
-          output.puts
-
-          block_flow = block_flows.fetch(block.id)
-          unless block_flow.in.empty?
-            output.puts "         # in: #{block_flow.in.join(", ")}"
-          end
-
-          block.each_with_length do |insn, length|
-            output.print("    ")
-            output.print(insn.disasm(fmt))
-
-            insn_flow = insn_flows[length]
-            if insn_flow.in.empty? && insn_flow.out.empty?
-              output.puts
-              next
+          fmt.output.puts(block.id)
+          fmt.with_prefix("    ") do
+            unless block.incoming_blocks.empty?
+              from = block.incoming_blocks.map(&:id).join(", ")
+              fmt.output.puts("#{fmt.current_prefix}== from: #{from}")
             end
 
-            output.print(" # ")
-            unless insn_flow.in.empty?
-              output.print("in: #{insn_flow.in.join(", ")}")
-              output.print("; ") unless insn_flow.out.empty?
+            block_flow = block_flows.fetch(block.id)
+            unless block_flow.in.empty?
+              fmt.output.puts("#{fmt.current_prefix}== in: #{block_flow.in.join(", ")}")
             end
 
-            unless insn_flow.out.empty?
-              output.print("out: #{insn_flow.out.join(", ")}")
+            fmt.format_insns!(block.insns, block.block_start) do |insn, length|
+              insn_flow = insn_flows[length]
+              next if insn_flow.in.empty? && insn_flow.out.empty?
+  
+              fmt.output.print(" # ")
+              unless insn_flow.in.empty?
+                fmt.output.print("in: #{insn_flow.in.join(", ")}")
+                fmt.output.print("; ") unless insn_flow.out.empty?
+              end
+  
+              unless insn_flow.out.empty?
+                fmt.output.print("out: #{insn_flow.out.join(", ")}")
+              end
             end
 
-            output.puts
-          end
-
-          dests = block.outgoing_blocks.map(&:id)
-          dests << "leaves" if block.insns.last.leaves?
-          output.puts("        # to: #{dests.join(", ")}") unless dests.empty?
+            to = block.outgoing_blocks.map(&:id)
+            to << "leaves" if block.insns.last.leaves?
+            fmt.output.puts("#{fmt.current_prefix}== to: #{to.join(", ")}")
 
-          unless block_flow.out.empty?
-            output.puts "        # out: #{block_flow.out.join(", ")}"
+            unless block_flow.out.empty?
+              fmt.output.puts("#{fmt.current_prefix}== out: #{block_flow.out.join(", ")}")
+            end  
           end
         end
 
-        output.string
+        fmt.string
       end
 
       # Verify that we constructed the data flow graph correctly.

lib/syntax_tree/yarv/disassembler.rb

@@ -146,6 +146,10 @@ def format_insns!(insns, length = 0)
               events.clear
             end
 
+            # A hook here to allow for custom formatting of instructions after
+            # the main body has been processed.
+            yield insn, length if block_given?
+
             output << "\n"
             length += insn.length
           end
@@ -166,13 +170,7 @@ def with_prefix(value)
       private
 
       def format_iseq(iseq)
-        output << "#{current_prefix}== disasm: "
-        output << "#<ISeq:#{iseq.name}@<compiled>:1 "
-
-        location = Location.fixed(line: iseq.line, char: 0, column: 0)
-        output << "(#{location.start_line},#{location.start_column})-"
-        output << "(#{location.end_line},#{location.end_column})"
-        output << "> "
+        output << "#{current_prefix}== disasm: #{iseq.inspect} "
 
         if iseq.catch_table.any?
           output << "(catch: TRUE)\n"

lib/syntax_tree/yarv/instruction_sequence.rb

@@ -276,6 +276,10 @@ def disasm
         fmt.string
       end
 
+      def inspect
+        "#<ISeq:#{name}@<compiled>:1 (#{line},#{0})-(#{line},#{0})>"
+      end
+
       # This method converts our linked list of instructions into a final array
       # and performs any other compilation steps necessary.
       def compile!

test/yarv_test.rb

@@ -335,31 +335,34 @@ def test_dfg
       dfg = SyntaxTree::YARV::DataFlowGraph.compile(cfg)
 
       assert_equal(<<~DFG, dfg.disasm)
-        == dfg <compiled>
+        == dfg: #<ISeq:<compiled>@<compiled>:1 (1,0)-(1,0)>
         block_0
-            putobject                              100 # out: out_0
-            putobject                              14 # out: 5
-            putobject_INT2FIX_0_ # out: 5
-            opt_lt                                 <calldata!mid:<, argc:1, ARGS_SIMPLE> # in: 2, 4; out: 7
-            branchunless                           13 # in: 5
-                # to: block_13, block_9
-                # out: 0
-        block_9 # from: block_0
-                 # in: pass_0
-            putobject                              -1 # out: out_0
-            jump                                   14
-                # to: block_14
-                # out: pass_0, 9
-        block_13 # from: block_0
-                 # in: pass_0
-            putobject_INT2FIX_1_ # out: out_0
-                # to: block_14
-                # out: pass_0, 13
-        block_14 # from: block_9, block_13
-                 # in: in_0, in_1
-            opt_plus                               <calldata!mid:+, argc:1, ARGS_SIMPLE> # in: in_0, in_1; out: 16
-            leave # in: 14
-                # to: leaves
+            0000 putobject                              100 # out: out_0
+            0002 putobject                              14 # out: 5
+            0004 putobject_INT2FIX_0_ # out: 5
+            0005 opt_lt                                 <calldata!mid:<, argc:1, ARGS_SIMPLE> # in: 2, 4; out: 7
+            0007 branchunless                           13 # in: 5
+            == to: block_13, block_9
+            == out: 0
+        block_9
+            == from: block_0
+            == in: pass_0
+            0009 putobject                              -1 # out: out_0
+            0011 jump                                   14
+            == to: block_14
+            == out: pass_0, 9
+        block_13
+            == from: block_0
+            == in: pass_0
+            0013 putobject_INT2FIX_1_ # out: out_0
+            == to: block_14
+            == out: pass_0, 13
+        block_14
+            == from: block_9, block_13
+            == in: in_0, in_1
+            0014 opt_plus                               <calldata!mid:+, argc:1, ARGS_SIMPLE> # in: in_0, in_1; out: 16
+            0016 leave # in: 14
+            == to: leaves
       DFG
     end