syntax_tree 5.0.0 → 5.1.0

data/lib/syntax_tree/yarv/decompiler.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module YARV
+    # This class is responsible for taking a compiled instruction sequence and
+    # walking through it to generate equivalent Ruby code.
+    class Decompiler
+      # When we're decompiling, we use a looped case statement to emulate
+      # jumping around in the same way the virtual machine would. This class
+      # provides convenience methods for generating the AST nodes that have to
+      # do with that label.
+      class BlockLabel
+        include DSL
+        attr_reader :name
+
+        def initialize(name)
+          @name = name
+        end
+
+        def field
+          VarField(Ident(name))
+        end
+
+        def ref
+          VarRef(Ident(name))
+        end
+      end
+
+      include DSL
+      attr_reader :iseq, :block_label
+
+      def initialize(iseq)
+        @iseq = iseq
+        @block_label = BlockLabel.new("__block_label")
+      end
+
+      def to_ruby
+        Program(decompile(iseq))
+      end
+
+      private
+
+      def node_for(value)
+        case value
+        when Integer
+          Int(value.to_s)
+        when Symbol
+          SymbolLiteral(Ident(value.to_s))
+        end
+      end
+
+      def decompile(iseq)
+        label = :label_0
+        clauses = {}
+        clause = []
+
+        iseq.insns.each do |insn|
+          case insn
+          when InstructionSequence::Label
+            unless clause.last.is_a?(Next)
+              clause << Assign(block_label.field, node_for(insn.name))
+            end
+
+            clauses[label] = clause
+            clause = []
+            label = insn.name
+          when BranchUnless
+            body = [
+              Assign(block_label.field, node_for(insn.label.name)),
+              Next(Args([]))
+            ]
+
+            clause << IfNode(clause.pop, Statements(body), nil)
+          when Dup
+            clause << clause.last
+          when DupHash
+            assocs =
+              insn.object.map do |key, value|
+                Assoc(node_for(key), node_for(value))
+              end
+
+            clause << HashLiteral(LBrace("{"), assocs)
+          when GetGlobal
+            clause << VarRef(GVar(insn.name.to_s))
+          when GetLocalWC0
+            local = iseq.local_table.locals[insn.index]
+            clause << VarRef(Ident(local.name.to_s))
+          when Jump
+            clause << Assign(block_label.field, node_for(insn.label.name))
+            clause << Next(Args([]))
+          when Leave
+            value = Args([clause.pop])
+            clause << (iseq.type == :top ? Break(value) : ReturnNode(value))
+          when OptAnd, OptDiv, OptEq, OptGE, OptGT, OptLE, OptLT, OptLTLT,
+               OptMinus, OptMod, OptMult, OptOr, OptPlus
+            left, right = clause.pop(2)
+            clause << Binary(left, insn.calldata.method, right)
+          when OptAref
+            collection, arg = clause.pop(2)
+            clause << ARef(collection, Args([arg]))
+          when OptAset
+            collection, arg, value = clause.pop(3)
+
+            clause << if value.is_a?(Binary) && value.left.is_a?(ARef) &&
+                 collection === value.left.collection &&
+                 arg === value.left.index.parts[0]
+              OpAssign(
+                ARefField(collection, Args([arg])),
+                Op("#{value.operator}="),
+                value.right
+              )
+            else
+              Assign(ARefField(collection, Args([arg])), value)
+            end
+          when OptNEq
+            left, right = clause.pop(2)
+            clause << Binary(left, :"!=", right)
+          when OptSendWithoutBlock
+            method = insn.calldata.method.to_s
+            argc = insn.calldata.argc
+
+            if insn.calldata.flag?(CallData::CALL_FCALL)
+              if argc == 0
+                clause.pop
+                clause << CallNode(nil, nil, Ident(method), Args([]))
+              elsif argc == 1 && method.end_with?("=")
+                _receiver, argument = clause.pop(2)
+                clause << Assign(
+                  CallNode(nil, nil, Ident(method[0..-2]), nil),
+                  argument
+                )
+              else
+                _receiver, *arguments = clause.pop(argc + 1)
+                clause << CallNode(
+                  nil,
+                  nil,
+                  Ident(method),
+                  ArgParen(Args(arguments))
+                )
+              end
+            else
+              if argc == 0
+                clause << CallNode(clause.pop, Period("."), Ident(method), nil)
+              elsif argc == 1 && method.end_with?("=")
+                receiver, argument = clause.pop(2)
+                clause << Assign(
+                  CallNode(receiver, Period("."), Ident(method[0..-2]), nil),
+                  argument
+                )
+              else
+                receiver, *arguments = clause.pop(argc + 1)
+                clause << CallNode(
+                  receiver,
+                  Period("."),
+                  Ident(method),
+                  ArgParen(Args(arguments))
+                )
+              end
+            end
+          when PutObject
+            case insn.object
+            when Float
+              clause << FloatLiteral(insn.object.inspect)
+            when Integer
+              clause << Int(insn.object.inspect)
+            else
+              raise "Unknown object type: #{insn.object.class.name}"
+            end
+          when PutObjectInt2Fix0
+            clause << Int("0")
+          when PutObjectInt2Fix1
+            clause << Int("1")
+          when PutSelf
+            clause << VarRef(Kw("self"))
+          when SetGlobal
+            target = GVar(insn.name.to_s)
+            value = clause.pop
+
+            clause << if value.is_a?(Binary) && VarRef(target) === value.left
+              OpAssign(VarField(target), Op("#{value.operator}="), value.right)
+            else
+              Assign(VarField(target), value)
+            end
+          when SetLocalWC0
+            target = Ident(local_name(insn.index, 0))
+            value = clause.pop
+
+            clause << if value.is_a?(Binary) && VarRef(target) === value.left
+              OpAssign(VarField(target), Op("#{value.operator}="), value.right)
+            else
+              Assign(VarField(target), value)
+            end
+          else
+            raise "Unknown instruction #{insn}"
+          end
+        end
+
+        # If there's only one clause, then we don't need a case statement, and
+        # we can just disassemble the first clause.
+        clauses[label] = clause
+        return Statements(clauses.values.first) if clauses.size == 1
+
+        # Here we're going to build up a big case statement that will handle all
+        # of the different labels.
+        current = nil
+        clauses.reverse_each do |current_label, current_clause|
+          current =
+            When(
+              Args([node_for(current_label)]),
+              Statements(current_clause),
+              current
+            )
+        end
+        switch = Case(Kw("case"), block_label.ref, current)
+
+        # Here we're going to make sure that any locals that were established in
+        # the label_0 block are initialized so that scoping rules work
+        # correctly.
+        stack = []
+        locals = [block_label.name]
+
+        clauses[:label_0].each do |node|
+          if node.is_a?(Assign) && node.target.is_a?(VarField) &&
+               node.target.value.is_a?(Ident)
+            value = node.target.value.value
+            next if locals.include?(value)
+
+            stack << Assign(node.target, VarRef(Kw("nil")))
+            locals << value
+          end
+        end
+
+        # Finally, we'll set up the initial label and loop the entire case
+        # statement.
+        stack << Assign(block_label.field, node_for(:label_0))
+        stack << MethodAddBlock(
+          CallNode(nil, nil, Ident("loop"), Args([])),
+          BlockNode(
+            Kw("do"),
+            nil,
+            BodyStmt(Statements([switch]), nil, nil, nil, nil)
+          )
+        )
+        Statements(stack)
+      end
+
+      def local_name(index, level)
+        current = iseq
+        level.times { current = current.parent_iseq }
+        current.local_table.locals[index].name.to_s
+      end
+    end
+  end
+end

data/lib/syntax_tree/yarv/disassembler.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+module SyntaxTree
+  module YARV
+    class Disassembler
+      attr_reader :output, :queue
+      attr_reader :current_prefix, :current_iseq
+
+      def initialize
+        @output = StringIO.new
+        @queue = []
+
+        @current_prefix = ""
+        @current_iseq = nil
+      end
+
+      ########################################################################
+      # Helpers for various instructions
+      ########################################################################
+
+      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(", ")}>"
+      end
+
+      def enqueue(iseq)
+        queue << iseq
+      end
+
+      def event(name)
+        case name
+        when :RUBY_EVENT_B_CALL
+          "Bc"
+        when :RUBY_EVENT_B_RETURN
+          "Br"
+        when :RUBY_EVENT_CALL
+          "Ca"
+        when :RUBY_EVENT_CLASS
+          "Cl"
+        when :RUBY_EVENT_END
+          "En"
+        when :RUBY_EVENT_LINE
+          "Li"
+        when :RUBY_EVENT_RETURN
+          "Re"
+        else
+          raise "Unknown event: #{name}"
+        end
+      end
+
+      def inline_storage(cache)
+        "<is:#{cache}>"
+      end
+
+      def instruction(name, operands = [])
+        operands.empty? ? name : "%-38s %s" % [name, operands.join(", ")]
+      end
+
+      def label(value)
+        value.name["label_".length..]
+      end
+
+      def local(index, explicit: nil, implicit: nil)
+        current = current_iseq
+        (explicit || implicit).times { current = current.parent_iseq }
+
+        value = "#{current.local_table.name_at(index)}@#{index}"
+        value << ", #{explicit}" if explicit
+        value
+      end
+
+      def object(value)
+        value.inspect
+      end
+
+      ########################################################################
+      # Main entrypoint
+      ########################################################################
+
+      def format!
+        while (@current_iseq = queue.shift)
+          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 = iseq.location
+        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
+        events = []
+        lines = []
+
+        iseq.insns.each do |insn|
+          case insn
+          when Integer
+            lines << insn
+          when Symbol
+            events << event(insn)
+          when InstructionSequence::Label
+            # skip
+          else
+            output << "#{current_prefix}%04d " % length
+
+            disasm = insn.disasm(self)
+            output << disasm
+
+            if lines.any?
+              output << " " * (65 - disasm.length) if disasm.length < 65
+            elsif events.any?
+              output << " " * (39 - disasm.length) if disasm.length < 39
+            end
+
+            if lines.any?
+              output << "(%4d)" % lines.last
+              lines.clear
+            end
+
+            if events.any?
+              output << "[#{events.join}]"
+              events.clear
+            end
+
+            output << "\n"
+            length += insn.length
+          end
+        end
+      end
+
+      def with_prefix(value)
+        previous = @current_prefix
+
+        begin
+          @current_prefix = value
+          yield
+        ensure
+          @current_prefix = previous
+        end
+      end
+    end
+  end
+end