laser 0.7.0.pre1

data/lib/laser/analysis/control_flow/method_call_search.rb

@@ -0,0 +1,26 @@
+module Laser
+  module Analysis
+    module ControlFlow
+      # Finds the properties of how the code yields to a block argument.
+      # Should not be used on top-level code, naturally.
+      module MethodCallSearch
+        def find_method_calls(method_to_find, opts)
+          possible_calls = []
+          reachable_vertices do |block|
+            block.instructions.each do |insn|
+              cur_insn = insn
+              if (insn.type == :call || insn.type == :call_vararg)
+                # check if method could be from insn receiver
+                if insn.possible_methods(opts).include?(method_to_find)
+                  possible_calls << insn
+                end
+              end
+            end
+          end
+          possible_calls
+        end
+      end
+    end  # ControlFlow
+  end  # Analysis
+end  #
+

data/lib/laser/analysis/control_flow/raise_properties.rb

@@ -0,0 +1,25 @@
+module Laser
+  module Analysis
+    module ControlFlow
+      # Finds the properties of how the code yields to a block argument.
+      # Should not be used on top-level code, naturally.
+      module RaiseProperties
+        def find_raise_properties
+          find_raise_frequency
+        end
+        
+        # Finds whether the method raises always, never, or sometimes.
+        def find_raise_frequency
+          fail_block = exception_postdominator
+          if fail_block.nil? || fail_block.real_predecessors.empty?
+            @raise_frequency = Frequency::NEVER
+          elsif (@exit.normal_predecessors & @exit.real_predecessors).empty?
+            @raise_frequency = Frequency::ALWAYS
+          else
+            @raise_frequency = Frequency::MAYBE
+          end
+        end
+      end
+    end
+  end
+end

data/lib/laser/analysis/control_flow/simulation.rb

@@ -0,0 +1,385 @@
+module Laser
+  module Analysis
+    module ControlFlow
+      # Simulation of a CFG. Requires values for the formal arguments, if any.
+      # Stops as soon as an unpredictable statement is reached.
+      module Simulation
+        class SimulationError < StandardError; end
+        class NonDeterminismHappened < StandardError; end
+        class SimulationNonterminationError < StandardError; end
+        class ExitedNormally < StandardError
+          attr_reader :result
+          def initialize(result)
+            @result = result
+          end
+        end
+        class ExitedAbnormally < StandardError
+          attr_reader :error
+          def initialize(error)
+            @error = error
+          end
+        end
+        MAX_SIMULATION_BLOCKS = 100_000
+        DEFAULT_SIMULATION_OPTS =
+            {on_raise: :annotate, invocation_sites: Hash.new { |h, k| h[k] = Set.new },
+             invocation_counts: Hash.new do |h1, block|
+               h1[block] = Hash.new { |h2, callsite| h2[callsite] = 0 }
+             end,
+             remaining_blocks: MAX_SIMULATION_BLOCKS,
+             method: nil }
+        # simulates the CFG, with different possible assumptions about
+        # how we should treat the global environment/self object.
+        def simulate(formal_vals=[], opts={})
+          opts = DEFAULT_SIMULATION_OPTS.merge(opts)
+          opts[:formals] = formal_vals
+          clear_analyses
+          current_block = opts[:start_block] || @enter
+          previous_block = nil
+          begin
+            loop do
+              simulate_take_step(opts)
+              from, next_block = simulate_block(current_block,
+                  opts.merge(previous_block: previous_block, current_block: current_block))
+              from.add_flag(next_block, ControlFlowGraph::EDGE_EXECUTABLE)
+              current_block, previous_block = next_block, current_block
+            end
+          rescue ExitedNormally => err
+            current_block.add_flag(current_block.normal_successors.first,
+                ControlFlowGraph::EDGE_EXECUTABLE)
+            err.result
+          rescue NonDeterminismHappened => err
+            Laser.debug_puts "Simulation ended at nondeterminism: #{err.message}"
+            Laser.debug_puts '>>> -- Starting Backup CP -- <<<'
+            perform_constant_propagation(initial_block: current_block, no_wipe: true)
+            Laser.debug_puts '>>> -- Finished Backup CP -- <<<'
+            raise err
+          rescue SimulationNonterminationError => err
+            Laser.debug_puts "Simulation failed to terminate: #{err.message}"
+            Laser.debug_p err.backtrace
+            @root.add_error(TopLevelSimulationRaised.new(err.message, @root, err))
+          rescue ExitedAbnormally => err
+            current_block.add_flag(current_block.exception_successors.first,
+                ControlFlowGraph::EDGE_EXECUTABLE)
+            if opts[:on_raise] == :annotate
+              msg = LaserObject === err.error ? err.error.laser_simulate('message', []) : err.error.message
+              Laser.debug_puts "Simulation exited abnormally: #{msg}"
+              @root.add_error(TopLevelSimulationRaised.new(msg, @root, err.error))
+            elsif opts[:on_raise] == :raise
+              raise err
+            end
+          rescue NotImplementedError => err
+            Laser.debug_puts "Simulation attempted: #{err.message}"
+            Laser.debug_p err.backtrace
+          end
+        end
+        
+        def simulate_take_step(opts)
+          if (opts[:remaining_blocks] -= 1) <= 0
+            raise SimulationNonterminationError.new('Simulation failed to terminate')
+          end
+        end
+        
+        def simulate_block(block, opts)
+          return if block.name == 'Exit'
+          
+          Laser.debug_puts "Entering block #{block.name}"
+          # phi nodes always go first
+          block.phi_nodes.each do |node|
+            simulate_deterministic_phi_node(node, opts)
+          end
+          block.natural_instructions[0..-2].each do |insn|
+            simulate_instruction(insn, opts)
+          end
+          if block.instructions.empty?
+            [opts[:current_block], block.real_successors.first]
+          else
+            simulate_exit_instruction(block.instructions.last, opts)
+          end
+        end
+        
+        def simulate_exit_instruction(insn, opts)
+          Laser.debug_puts "Simulating exit insn: #{insn.inspect}"
+          natural_exit = insn.block.normal_successors.first
+          case insn[0]
+          when :jump
+            [opts[:current_block], insn.block.real_successors.first]
+          when :branch
+            Laser.debug_puts "Branching on: #{insn[1].value.inspect}"
+            [opts[:current_block], insn[1].value ? insn.true_successor : insn.false_successor]
+          when :call, :call_vararg, :super, :super_vararg
+            # todo: block edge!
+            begin
+              simulate_instruction(insn, opts)
+              if (call_block = insn[-1][:block])
+                block_proc = call_block.value
+                if opts[:invocation_counts][block_proc][opts[:current_block]] > 0
+                  executed_succ = opts[:current_block].successors.find { |b| b.name == block_proc.start_block.name }
+                  opts[:current_block].add_flag(executed_succ,
+                      ControlFlowGraph::EDGE_EXECUTABLE)
+                  [self[block_proc.exit_block], natural_exit]
+                else
+                  [opts[:current_block], natural_exit]
+                end
+              else
+                [opts[:current_block], natural_exit]
+              end
+            rescue ExitedAbnormally => err
+              Laser.debug_puts "Exception raised by call, taking abnormal edge. Error: #{err.error}"
+              Laser.debug_pp(err.backtrace)
+              [opts[:current_block], insn.block.exception_successors.first]
+            end
+          when :return
+            raise ExitedNormally.new(insn[1].value)
+          when :raise
+            raise ExitedAbnormally.new(insn[1].value)
+          else
+            raise ArgumentError.new("Unexpected instruction type #{insn[0].inspect}")
+          end 
+        end
+
+        def simulate_deterministic_phi_node(node, opts)
+          # Laser.debug_puts "Simulating #{node.inspect} from #{opts[:previous_block].name}"
+          index_of_predecessor = node.block.predecessors.to_a.index(opts[:previous_block])
+          simulate_assignment(node[1], node[2 + index_of_predecessor], opts)
+        end
+        
+        def simulate_assignment(lhs, rhs, opts)
+          if Bindings::Base === rhs
+            lhs.bind! rhs.value
+          else
+            lhs.bind! rhs
+          end
+        end
+        
+        def simulate_instruction(insn, opts)
+          Laser.debug_puts "Simulating insn: #{insn.inspect}"
+          case insn[0]
+          when :assign then simulate_assignment(insn[1], insn[2], opts)
+          when :call, :call_vararg
+            # cases: special method we intercept, builtin we direct-send, and cfg we simulate
+            simulate_call_instruction(insn, opts)
+          when :super, :super_vararg
+            if opts[:method].nil?
+              raise ExitedAbnormally.new(NoMethodError.new('super called outside of method'))
+            else
+              simulate_call_instruction(insn, opts)
+            end
+          when :declare
+            # do nothing
+          else
+            raise ArgumentError.new("Unexpected instruction type #{insn[0].inspect}")
+          end
+        end
+
+        def simulate_call_instruction(insn, opts)
+          if insn.operands.any? { |op| op.value == VARYING || op.value == UNDEFINED }
+            raise NonDeterminismHappened.new(
+                "Nondeterministic operand (#{op.name}=#{op.value} in #{insn.inspect})")
+          end
+          receiver = insn[2].value
+          klass = Utilities.klass_for(receiver)
+          if insn.type == :call || insn.type == :call_vararg
+            method = klass.instance_method(insn[3])  # normal method dispatch
+          else
+            # super method dispatch
+            method = opts[:method].owner.parent.instance_method(opts[:method].name)
+          end
+          if !method
+            simulate_method_missing(insn, klass)
+          elsif should_simulate_call(method, opts)
+            simulate_call(receiver, method, insn, opts)
+          else
+            raise NonDeterminismHappened.new("Nondeterministic call: #{method.owner.name}##{method.name}")
+          end
+        end
+
+        def simulate_call(receiver, method, insn, opts)
+          args = simulate_args(insn)
+          block_to_use = insn[-1][:block] && insn[-1][:block].value
+          result = simulate_call_dispatch(receiver, method, args, block_to_use, opts)
+          insn[1].bind! result if insn[1]
+        end
+        
+        def simulate_args(insn)
+          case insn.type
+          when :call
+            insn[4..-2].map(&:value)
+          when :call_vararg
+            insn[4].value
+          when :super
+            insn[2..-2].map(&:value)
+          when :super_vararg
+            insn[2].value
+          end
+        end
+
+        def should_simulate_call(method, opts)
+          method.predictable && (opts[:mutation] || !method.mutation)
+        end
+        
+        def simulate_call_dispatch(receiver, method, args, block, opts)
+          Laser.debug_puts("simulate_call(#{receiver.inspect}, #{method.name}, #{args.inspect}, #{block.inspect}, #{opts.inspect})")
+          opts = opts.merge(method: method)
+          if block
+            new_invocation_sites = opts[:invocation_sites].merge(block => opts[:invocation_sites][block] | Set[opts[:current_block]])
+            opts = opts.merge(invocation_sites: new_invocation_sites, on_raise: :raise)
+          end
+          method.been_used!
+          if method.special
+            simulate_special_method(receiver, method, args, block, opts)
+          elsif method.builtin
+            begin
+              if !block
+                receiver.send(method.name, *args)
+              else
+                result = receiver.send(method.name, *args) do |*given_args, &given_blk|
+                  # self is this because no builtins change self... right?
+                  block.simulate(given_args, given_blk, opts)
+                end
+                result
+              end
+            rescue ExitedAbnormally => abnormal
+              Bootstrap::EXCEPTION_STACK.value.push(abnormal.error)
+              raise abnormal
+            # Extremely unsafe exception handler: assumes my code does not raise
+            # exceptions!
+            rescue Exception => err
+              Laser.debug_puts("Internal exception raised: #{err.message}")
+              Laser.debug_pp(err.backtrace)
+              Bootstrap::EXCEPTION_STACK.value.push(err)
+              raise ExitedAbnormally.new(err)
+            end
+          else
+            Laser.debug_puts "About to simulate #{method.owner.name}##{method.name}"
+            result = method.simulate_with_args(receiver, args, block, opts)
+            Laser.debug_puts "Finished simulating #{method.owner.name}##{method.name} => #{result.inspect}"
+            result
+          end
+        end
+        
+        def simulate_method_missing(insn, klass)
+          error_klass = insn.node.type == :vcall ? 'NameError' : 'NoMethodError'
+          missing_method_error = ClassRegistry[error_klass].laser_simulate(
+              'new', ["Method missing: #{klass.name}##{insn[3]}", insn[3].to_s])
+          Bootstrap::EXCEPTION_STACK.value.push(missing_method_error)
+          raise ExitedAbnormally.new(missing_method_error)
+        end
+        
+        def simulate_special_method(receiver, method, args, block, opts)
+          case method
+          when ClassRegistry['Class'].instance_method(:allocate)
+            LaserObject.new(receiver, nil)
+          when ClassRegistry['Class'].singleton_class.instance_method(:new)
+            LaserClass.new(ClassRegistry['Class'], nil) do |klass|
+              klass.superclass = args.first
+            end
+          when ClassRegistry['Module'].singleton_class.instance_method(:new)
+            LaserModule.new
+          when ClassRegistry['Kernel'].instance_method(:require)
+            simulate_require(args)
+          when ClassRegistry['Kernel'].instance_method(:send)
+            method_name, *actual_args = args
+            klass = Utilities.klass_for(receiver)
+            method = klass.instance_method(method_name)
+            if should_simulate_call(method, opts)
+              simulate_call_dispatch(receiver, method, actual_args, block, opts)
+            else
+              raise NonDeterminismHappened.new("Nondeterministic call: #{method.inspect}")
+            end
+          when ClassRegistry['Module'].instance_method(:define_method)
+            simulate_define_method(receiver, args, block)
+          when ClassRegistry['Module'].instance_method(:module_eval)
+            simulate_module_eval(receiver, args, block)
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:get_global)
+            Scope::GlobalScope.lookup(args.first).value
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:set_global)
+            Scope::GlobalScope.lookup(args[0]).bind!(args[1])
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:current_self)
+            opts[:self]
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:current_block)
+            opts[:block]
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:current_arity)
+            opts[:formals].size
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:current_argument)
+            opts[:formals][args.first]
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:current_argument_range)
+            opts[:formals][args[0], args[1]]
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:current_exception),
+               ClassRegistry['Laser#Magic'].singleton_class.instance_method(:get_just_raised_exception)
+            Bootstrap::EXCEPTION_STACK.value.last
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:push_exception)
+            Bootstrap::EXCEPTION_STACK.value.push args[0]
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:pop_exception)
+            Bootstrap::EXCEPTION_STACK.value.pop
+          when ClassRegistry['Laser#Magic'].singleton_class.instance_method(:responds?)
+            receiver, method_name = args
+            Utilities.klass_for(receiver).instance_method(method_name)
+          when Scope::GlobalScope.self_ptr.singleton_class.instance_method(:private)
+            ClassRegistry['Object'].private(*args)
+          when Scope::GlobalScope.self_ptr.singleton_class.instance_method(:public)
+            ClassRegistry['Object'].public(*args)
+          end
+        end
+        
+        def reset_simulation!
+          all_variables.each do |temp|
+            temp.bind! UNDEFINED
+            temp.inferred_type = nil
+          end
+          vertices.each do |block|
+            block.successors.each do |succ|
+              block.remove_flag(succ, ControlFlowGraph::EDGE_EXECUTABLE)
+            end
+          end
+        end
+        
+        def simulate_define_method(receiver, args, block)
+          if args.size == 1 && block
+            receiver.define_method(args.first, block)
+          elsif args.size == 2
+            receiver.define_method(args[0], args[1])
+          else
+            raise ArgumentError.new("wrong number of arguments (#{args.size} for 1..2)")
+          end
+        end
+        
+        # TODO(adgar): validate arguments
+        # TODO(adgar): make errors visible
+        def simulate_require(args)
+          file = args.first
+          load_path = Scope::GlobalScope.lookup('$:').value
+          loaded_values = Scope::GlobalScope.lookup('$"').value
+          to_load = file + '.rb'
+          load_path.each do |path|
+            joined = File.join(path, to_load)
+            if File.exist?(joined)
+              if !loaded_values.include?(joined)
+                tree = Annotations.annotate_inputs([[joined, File.read(joined)]], optimize: false)
+                #node.errors.concat tree[0][1].all_errors
+                return true
+              end
+              return false
+            end
+          end
+          raise LoadError.new("No such file: #{file}")
+        end
+        
+        def simulate_module_eval(receiver, args, block)
+          # essentially: parse, compile with a custom scope + lexical target (cref), simulate.
+          if args.size > 0
+            text = args[0]
+            file = args[1] || "(eval)"
+            line = args[2] || 1  # ignored currently
+            tree = Sexp.new(RipperPlus.sexp(text), file, text)
+            Annotations.ordered_annotations.each do |annotator|
+              annotator.annotate_with_text(tree, text)
+            end
+            custom_scope = ClosedScope.new(Scope::GlobalScope, receiver.binding)
+            cfg = GraphBuilder.new(tree, [], custom_scope).build
+            cfg.analyze
+          end
+        end
+      end  # Simulation
+    end  # ControlFlow
+  end  # Analysis
+end  # Laser

data/lib/laser/analysis/control_flow/static_single_assignment.rb

@@ -0,0 +1,185 @@
+module Laser
+  module Analysis
+    module ControlFlow
+      # Methods for computing the static single assignment form of a
+      # Control Flow Graph.
+      module StaticSingleAssignment
+        # SSA Form
+        def static_single_assignment_form
+          calculate_live
+          dom_tree = dominator_tree
+          place_phi_nodes(dom_tree)
+          ssa_name_formals
+          rename_for_ssa(enter, dom_tree)
+          @in_ssa = true
+          self
+        end
+        
+      private
+       
+        # Places phi nodes, minimally, using DF+
+        def place_phi_nodes(dom_tree)
+          @globals.each do |temp|
+            set = @definition_blocks[temp] | Set[enter]
+            iterated_dominance_frontier(set, dom_tree).each do |block|
+              if @live[temp].include?(block)
+                n = block.real_predecessors.size
+                block.instructions.unshift(Instruction.new([:phi, temp, *([temp] * n)], block: block))
+              end
+            end
+          end
+        end
+        
+        # Sets up SSA to handle the formal arguments
+        def ssa_name_formals
+          self_binding = @root.scope.lookup('self')
+          @name_stack[self_binding].push(self_binding)
+        end
+
+        # Renames all variables in the block, and all blocks it dominates,
+        # to SSA-form variables by adding a suffix of the form #\d. Since
+        # '#' is not allowed in an identifier's name, it will be clear
+        # visually what part of the name is the SSA suffix, and it is trivially
+        # stripped algorithmically to determine which original temp it refers to.
+        #
+        # p.175, Morgan
+        def rename_for_ssa(block, dom_tree)
+          # Note the definition caused by all phi nodes in the block, as
+          # phi nodes are evaluated immediately upon entering a block.
+          block.phi_nodes.each do |phi_node|
+            temp = phi_node[1]
+            @name_stack[temp].push(new_ssa_name(temp))
+            ssa_name_for(temp).definition = phi_node
+            @all_cached_variables << ssa_name_for(temp)
+          end
+          # Replace current operands and note new definitions
+          block.natural_instructions.each do |ins|
+            new_operands = []
+            ins.operands.each do |temp|
+              ssa_uninitialize_fix(temp, block, ins) if ssa_name_for(temp).nil?
+              ssa_name_for(temp).uses << ins
+              new_operands << ssa_name_for(temp)
+            end
+            if ins.block_operand
+              new_block_operand = ssa_name_for(ins.block_operand)
+              new_block_operand.uses << ins
+              ins.replace_block_operand(new_block_operand)
+            end
+            ins.replace_operands(new_operands) unless ins.operands.empty?
+            ins.explicit_targets.each do |temp|
+              if temp != Bootstrap::VISIBILITY_STACK
+                @name_stack[temp].push(new_ssa_name(temp))
+                ssa_name_for(temp).definition = ins
+                @all_cached_variables << ssa_name_for(temp)
+              end
+            end
+          end
+          # Update all phi nodes this block leads to with the name of
+          # the variable this block uses
+          # TODO(adgar): make ordering more reliable, it currently relies
+          #   on the fact that Set uses Hash, and Hashes in 1.9 are ordered
+          block.real_successors.each do |succ|
+            j = succ.real_predecessors.to_a.index(block)
+            tweaked_phi_nodes = ssa_uninitialized_phinode_fix(block, succ, j)
+            succ.phi_nodes.each do |phi_node|
+              replacement = ssa_name_for(phi_node[j + 2])
+              phi_node[j + 2] = replacement
+              replacement.uses << phi_node
+            end
+            tweaked_phi_nodes.each do |phi_node|
+              @name_stack[phi_node[1]].pop
+            end
+          end
+          # Recurse to dominated blocks
+          dom_tree[block].each_real_predecessors do |pred|
+            rename_for_ssa(self[pred], dom_tree)
+          end
+          # Update all targets with the current definition
+          block.natural_instructions.reverse_each do |ins|
+            ins.explicit_targets.each do |target|
+              if target != Bootstrap::VISIBILITY_STACK
+                ins.replace_target(target, @name_stack[target].pop)
+              end
+            end
+          end
+
+          block.phi_nodes.each do |ins|
+            ins[1] = @name_stack[ins[1]].pop
+          end
+        end
+
+        def ssa_uninitialized_phinode_fix(block, succ, j)
+          phi_nodes_with_undefined_ops = succ.phi_nodes.select do |phi_node|
+            ssa_name_for(phi_node[j+2]).nil?
+          end
+          if phi_nodes_with_undefined_ops.any?
+            fixup_block = ssa_phinode_fixup_block(block, succ, j)
+            phi_nodes_with_undefined_ops.each do |phi_node|
+              assign = ssa_uninitialize_fixing_instruction(
+                  phi_node[1], phi_node, fixup_block, true)
+              fixup_block.instructions << assign
+            end
+            fixup_block.instructions << Instruction.new([:jump, succ.name], node: nil, block: fixup_block)
+          end
+          phi_nodes_with_undefined_ops
+        end
+
+        def ssa_phinode_fixup_block(predecessor, block, j)
+          fixup_block = BasicBlock.new("SSA-FIX-#{block.name}-#{j}")
+          add_vertex(fixup_block)
+
+          predecessor.insert_block_on_edge(block, fixup_block)
+
+          exit_insn = predecessor.instructions.last
+          if exit_insn && exit_insn.type == :jump
+            exit_insn[1] = fixup_block.name
+          elsif exit_insn && exit_insn.type == :branch
+            exit_insn[exit_insn.index(block.name)] = fixup_block.name
+          end
+
+          fixup_block
+        end
+
+        # If a block uses a variable in a non-phi instruction, but there
+        # is no name for that variable on the current path, then it is
+        # being read before it has been written. Uninitialized variables
+        # have value nil, so before the read, insert an assignment to
+        # nil. SSA will take over from there.
+        def ssa_uninitialize_fix(temp, block, ins)
+          assignment = ssa_uninitialize_fixing_instruction(temp, ins, block)
+          block.instructions.insert(block.instructions.index(ins), assignment)
+        end
+
+        def ssa_uninitialize_fixing_instruction(temp, reading_ins, block, renamed=false)
+          @name_stack[temp].push(new_ssa_name(temp))
+          @all_cached_variables << ssa_name_for(temp)
+          target = renamed ? ssa_name_for(temp) : temp
+          assignment = Instruction.new([:assign, target, nil],
+              node: reading_ins.node, block: block)
+          ssa_name_for(temp).definition = assignment
+        end
+
+        def ssa_name_for(temp)
+          @name_stack[temp].last
+        end
+        
+        def new_ssa_name(temp)
+          @name_count[temp] += 1
+          name = "#{temp.name}##{@name_count[temp]}"
+          result = Bindings::TemporaryBinding.new(name, nil)
+          if temp == @final_return
+            @final_return = result
+          elsif temp == @final_exception
+            @final_exception = result
+          elsif temp == @block_register
+            @block_register = result
+          elsif (scope_owner = temp.self_owner)
+            result.self_owner = scope_owner
+            scope_owner.self_ptr = result
+          end
+          result
+        end
+      end
+    end
+  end
+end