syntax_tree 5.3.0 → 6.0.0

data/lib/syntax_tree/yarv/disassembler.rb

@@ -3,16 +3,52 @@
 module SyntaxTree
   module YARV
     class Disassembler
+      # This class is another object that handles disassembling a YARV
+      # instruction sequence but it renders it without any of the extra spacing
+      # or alignment.
+      class Squished
+        def calldata(value)
+          value.inspect
+        end
+
+        def enqueue(iseq)
+        end
+
+        def event(name)
+        end
+
+        def inline_storage(cache)
+          "<is:#{cache}>"
+        end
+
+        def instruction(name, operands = [])
+          operands.empty? ? name : "#{name} #{operands.join(", ")}"
+        end
+
+        def label(value)
+          "%04d" % value.name["label_".length..]
+        end
+
+        def local(index, **)
+          index.inspect
+        end
+
+        def object(value)
+          value.inspect
+        end
+      end
+
       attr_reader :output, :queue
+
       attr_reader :current_prefix
       attr_accessor :current_iseq
 
-      def initialize
+      def initialize(current_iseq = nil)
         @output = StringIO.new
         @queue = []
 
         @current_prefix = ""
-        @current_iseq = nil
+        @current_iseq = current_iseq
       end
 
       ########################################################################
@@ -20,30 +56,7 @@ module SyntaxTree
       ########################################################################
 
       def calldata(value)
-        flag_names = []
-        flag_names << :ARGS_SPLAT if value.flag?(CallData::CALL_ARGS_SPLAT)
-        if value.flag?(CallData::CALL_ARGS_BLOCKARG)
-          flag_names << :ARGS_BLOCKARG
-        end
-        flag_names << :FCALL if value.flag?(CallData::CALL_FCALL)
-        flag_names << :VCALL if value.flag?(CallData::CALL_VCALL)
-        flag_names << :ARGS_SIMPLE if value.flag?(CallData::CALL_ARGS_SIMPLE)
-        flag_names << :BLOCKISEQ if value.flag?(CallData::CALL_BLOCKISEQ)
-        flag_names << :KWARG if value.flag?(CallData::CALL_KWARG)
-        flag_names << :KW_SPLAT if value.flag?(CallData::CALL_KW_SPLAT)
-        flag_names << :TAILCALL if value.flag?(CallData::CALL_TAILCALL)
-        flag_names << :SUPER if value.flag?(CallData::CALL_SUPER)
-        flag_names << :ZSUPER if value.flag?(CallData::CALL_ZSUPER)
-        flag_names << :OPT_SEND if value.flag?(CallData::CALL_OPT_SEND)
-        flag_names << :KW_SPLAT_MUT if value.flag?(CallData::CALL_KW_SPLAT_MUT)
-
-        parts = []
-        parts << "mid:#{value.method}" if value.method
-        parts << "argc:#{value.argc}"
-        parts << "kw:[#{value.kw_arg.join(", ")}]" if value.kw_arg
-        parts << flag_names.join("|") if flag_names.any?
-
-        "<calldata!#{parts.join(", ")}>"
+        value.inspect
       end
 
       def enqueue(iseq)
@@ -97,7 +110,7 @@ module SyntaxTree
       end
 
       ########################################################################
-      # Main entrypoint
+      # Entrypoints
       ########################################################################
 
       def format!
@@ -105,63 +118,13 @@ module SyntaxTree
           output << "\n" if output.pos > 0
           format_iseq(@current_iseq)
         end
-
-        output.string
       end
 
-      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 << "> "
-
-        if iseq.catch_table.any?
-          output << "(catch: TRUE)\n"
-          output << "#{current_prefix}== catch table\n"
-
-          with_prefix("#{current_prefix}| ") do
-            iseq.catch_table.each do |entry|
-              case entry
-              when InstructionSequence::CatchBreak
-                output << "#{current_prefix}catch type: break\n"
-                format_iseq(entry.iseq)
-              when InstructionSequence::CatchNext
-                output << "#{current_prefix}catch type: next\n"
-              when InstructionSequence::CatchRedo
-                output << "#{current_prefix}catch type: redo\n"
-              when InstructionSequence::CatchRescue
-                output << "#{current_prefix}catch type: rescue\n"
-                format_iseq(entry.iseq)
-              end
-            end
-          end
-
-          output << "#{current_prefix}|#{"-" * 72}\n"
-        else
-          output << "(catch: FALSE)\n"
-        end
-
-        if (local_table = iseq.local_table) && !local_table.empty?
-          output << "#{current_prefix}local table (size: #{local_table.size})\n"
-
-          locals =
-            local_table.locals.each_with_index.map do |local, index|
-              "[%2d] %s@%d" % [local_table.offset(index), local.name, index]
-            end
-
-          output << "#{current_prefix}#{locals.join("    ")}\n"
-        end
-
-        length = 0
+      def format_insns!(insns, length = 0)
         events = []
         lines = []
 
-        iseq.insns.each do |insn|
+        insns.each do |insn|
           case insn
           when Integer
             lines << insn
@@ -191,22 +154,83 @@ module SyntaxTree
               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
         end
       end
 
+      def print(string)
+        output.print(string)
+      end
+
+      def puts(string)
+        output.puts(string)
+      end
+
+      def string
+        output.string
+      end
+
       def with_prefix(value)
         previous = @current_prefix
 
         begin
           @current_prefix = value
-          yield
+          yield value
         ensure
           @current_prefix = previous
         end
       end
+
+      private
+
+      def format_iseq(iseq)
+        output << "#{current_prefix}== disasm: #{iseq.inspect} "
+
+        if iseq.catch_table.any?
+          output << "(catch: TRUE)\n"
+          output << "#{current_prefix}== catch table\n"
+
+          with_prefix("#{current_prefix}| ") do
+            iseq.catch_table.each do |entry|
+              case entry
+              when InstructionSequence::CatchBreak
+                output << "#{current_prefix}catch type: break\n"
+                format_iseq(entry.iseq)
+              when InstructionSequence::CatchNext
+                output << "#{current_prefix}catch type: next\n"
+              when InstructionSequence::CatchRedo
+                output << "#{current_prefix}catch type: redo\n"
+              when InstructionSequence::CatchRescue
+                output << "#{current_prefix}catch type: rescue\n"
+                format_iseq(entry.iseq)
+              end
+            end
+          end
+
+          output << "#{current_prefix}|#{"-" * 72}\n"
+        else
+          output << "(catch: FALSE)\n"
+        end
+
+        if (local_table = iseq.local_table) && !local_table.empty?
+          output << "#{current_prefix}local table (size: #{local_table.size})\n"
+
+          locals =
+            local_table.locals.each_with_index.map do |local, index|
+              "[%2d] %s@%d" % [local_table.offset(index), local.name, index]
+            end
+
+          output << "#{current_prefix}#{locals.join("    ")}\n"
+        end
+
+        format_insns!(iseq.insns)
+      end
     end
   end
 end

data/lib/syntax_tree/yarv/instruction_sequence.rb

@@ -7,6 +7,28 @@ module SyntaxTree
     # list of instructions along with the metadata pertaining to them. It also
     # functions as a builder for the instruction sequence.
     class InstructionSequence
+      # This provides a handle to the rb_iseq_load function, which allows you
+      # to pass a serialized iseq to Ruby and have it return a
+      # RubyVM::InstructionSequence object.
+      def self.iseq_load(iseq)
+        require "fiddle"
+
+        @iseq_load_function ||=
+          Fiddle::Function.new(
+            Fiddle::Handle::DEFAULT["rb_iseq_load"],
+            [Fiddle::TYPE_VOIDP] * 3,
+            Fiddle::TYPE_VOIDP
+          )
+
+        Fiddle.dlunwrap(@iseq_load_function.call(Fiddle.dlwrap(iseq), 0, nil))
+      rescue LoadError
+        raise "Could not load the Fiddle library"
+      rescue NameError
+        raise "Unable to find rb_iseq_load"
+      rescue Fiddle::DLError
+        raise "Unable to perform a dynamic load"
+      end
+
       # When the list of instructions is first being created, it's stored as a
       # linked list. This is to make it easier to perform peephole optimizations
       # and other transformations like instruction specialization.
@@ -60,19 +82,6 @@ module SyntaxTree
 
       MAGIC = "YARVInstructionSequence/SimpleDataFormat"
 
-      # This provides a handle to the rb_iseq_load function, which allows you to
-      # pass a serialized iseq to Ruby and have it return a
-      # RubyVM::InstructionSequence object.
-      ISEQ_LOAD =
-        begin
-          Fiddle::Function.new(
-            Fiddle::Handle::DEFAULT["rb_iseq_load"],
-            [Fiddle::TYPE_VOIDP] * 3,
-            Fiddle::TYPE_VOIDP
-          )
-        rescue NameError, Fiddle::DLError
-        end
-
       # This object is used to track the size of the stack at any given time. It
       # is effectively a mini symbolic interpreter. It's necessary because when
       # instruction sequences get serialized they include a :stack_max field on
@@ -221,8 +230,7 @@ module SyntaxTree
       end
 
       def eval
-        raise "Unsupported platform" if ISEQ_LOAD.nil?
-        Fiddle.dlunwrap(ISEQ_LOAD.call(Fiddle.dlwrap(to_a), 0, nil)).eval
+        InstructionSequence.iseq_load(to_a).eval
       end
 
       def to_a
@@ -269,10 +277,27 @@ module SyntaxTree
         ]
       end
 
+      def to_cfg
+        ControlFlowGraph.compile(self)
+      end
+
+      def to_dfg
+        to_cfg.to_dfg
+      end
+
+      def to_son
+        to_dfg.to_son
+      end
+
       def disasm
-        disassembler = Disassembler.new
-        disassembler.enqueue(self)
-        disassembler.format!
+        fmt = Disassembler.new
+        fmt.enqueue(self)
+        fmt.format!
+        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