rpicsim 0.4.0 → 1.0.0

data/docs/PreventingCallStackOverflow.md

@@ -1,92 +0,0 @@
-Preventing call stack overflow
-====
-
-PIC microcontrollers feature a stack implemented in hardware that keeps track of return addresses for subroutine calls.
-Every time a `CALL` instruction is executed, the return address is pushed onto the stack.
-Every time a `RETURN` or similar instruction is executed, the return address is popped off of the stack.
-
-The call stack has a limited depth that depends on the device you are using.
-If your program has too many levels of nested subroutines then the call stack could overflow.
-Depending on the device, a call stack overflow could cause a reset or incorrect program execution.
-Therefore, it is important to avoid a call stack overflow.
-
-RPicSim can trace all the possible paths of execution for a PIC program in order to calculate what the maximum possible call stack depth is.
-You can easily add this to your RSpec tests.
-Here is an example:
-
-    !!!ruby
-    describe "call stack" do
-      subject(:call_stack_info) do
-        RPicSim::CallStackInfo.hash_from_program_file(MySim.program_file, [0, 4])
-      end
-
-      specify "mainline code uses no more than 5 levels" do
-        call_stack_info[0].max_depth be <= 5
-      end
-
-      specify "ISR code uses no more than 1 level" do
-        call_stack_info[4].max_depth.should be <= 1
-      end
-    end
-
-This example is for a PIC10F322 program.
-The mainline code's entry point is at address 0, and the first RSpec example makes sure that the maximum depth of subroutine calls in the mainline code is 5.
-The firmware uses an interrupt and the interrupt vector is at address 4.
-The second RSpec example makes sure that the ISR uses at most one level of the call stack (the ISR itself can only call one subroutine).
-
-If the two tests above pass, then we can calculate the maximum amount of call stack space that might ever be used.  If the mainline code is at its deepest point and it is interrupted by an ISR that happens to reach its deepest point, then the call stack would have:
-
-* 5 levels used by the mainline code.
-* 1 level used by the processor itself to store the address to return to when the interrupt is done.
-* 1 level used by the ISR code.
-
-The means there can be at most 7 things stored on the call stack, which is safely below the PIC10F322's limit of 8.
-
-Suppose RPicSim tells you that your mainline code could take 5 levels of the stack and you are not sure why.
-The {RPicSim::CallStackInfo#worst_case_code_paths_filtered_report} can produce a set of example code paths that demonstrate how the maximum depth could potentially happen.
-To see the report, just add a line like this:
-
-    !!!ruby
-    p call_stack_info[0].worst_case_code_paths_filtered_report
-
-The report will be a series of code paths that look something like this:
-
-    !!!plain
-    CodePath:
-    Instruction(0x0000, GOTO 0x20)
-    Instruction(0x0024 = start2, CALL 0x40)
-    Instruction(0x0040 = foo, CALL 0x41)
-    Instruction(0x0041 = goo, CALL 0x60)
-    Instruction(0x0060 = hoo, CALL 0x80)
-    Instruction(0x0080 = ioo, CALL 0x100)
-    Instruction(0x0100 = joo, CLRF 0x7)
-
-This example code path shows five CALL instructions that could potentially be nested.
-
-How it works
-----
-
-The {RPicSim::ProgramFile} class uses the MPLAB X disassembler to provide a graph with every reachable instruction in the firmware.
-The {RPicSim::CallStackInfo} class traverses all possible paths through that graph from a given entry point to calculate the maximum possible call stack depth at every point in the graph.
-
-Limitations
-----
-
-The algorithm is pessimistic:
-
-* It does not try to track the runtime values of any of your program's variables in order to predict which code paths will happen.
-* It cannot handle recursive functions because there is no way for it to figure out the maximum level of recursion.
-* It does not know when interrupts are enabled.
-
-All of those things are OK because they can only cause the algorithm to give an answer that is more pessimistic than reality; the reported maximum call stack depth might be higher than what is actually possible.
-
-However, there are some things that can mess up the algorithm in a bad way and give you incorrect results:
-
-* If you write to the PC register in order to do a computed jump, the algorithm does not currently detect that and will not correctly consider code paths coming from that instruction.
-  Be careful about this, because a computed jump might be generated automatically by a C compiler.
-* Similarly, it cannot handle jumps on devices that have paged memory.  In order to determine where a jump actually goes, it would need to know what page is selected by looking at the history of the program's execution.
-* It does not account for the effect of PUSH and POP instructions on the call stack depth.
-
-This code is not suitable (yet) for any firmware that uses a computed jump, paged program memory, or PUSH or POP instructions.
-  
-This code only checks the hardware call stack; it does not check any kind of data stack that your compiler might use to store the values of local variables.

data/lib/rpicsim/call_stack_info.rb

@@ -1,303 +0,0 @@
-require_relative 'search'
-require 'set'
-
-module RPicSim
-  # This class helps analyze programs to see whether it is possible for them
-  # to overflow the call stack, which is limited to a small number of levels on
-  # many PIC microcontrollers.
-  # It traverses the {Instruction} graph provided by a {ProgramFile}
-  # from a given root node and for each reachable instruction determines the
-  # maximum possible call stack depth when that instruction starts executing,
-  # relative to how deep the call stack depth was when the root instruction
-  # started.
-  #
-  # Here is an example of how you would use this to check the call stack depth
-  # in a program that has one interrupt vector at address 4 inside an RSpec test.
-  # Of course, you should adjust the numbers to suit your application:
-  #
-  #     infos = CallStackInfo.hash_from_program_file(program_file, [0, 4])
-  #     infos[0].max_depth.should <= 5  # main-line code should take at most 5 levels
-  #     infos[4].max_depth.should <= 1  # ISR should take at most 1 stack level
-  #
-  # Additionally, it can generate reports of all different ways that the maximum
-  # call stack depth can be achieved, which can be helpful if you need to reduce
-  # your maximum stack depth.
-  class CallStackInfo
-    # For each of the given root instruction addresses, generates a {CallStackInfo}
-    # report.  Returns the reports in a hash.
-    #
-    # @param program_file (ProgramFile)
-    # @param root_instruction_addresses Array(Integer)  The program memory
-    #   addresses of the entry vectors for your program.  On a midrange device, these
-    #   are typically 0 for the main-line code and 4 for the interrupt.
-    # @return [Hash(address => CallStackInfo)]
-    def self.hash_from_program_file(program_file, root_instruction_addresses)
-      infos = {}
-      root_instruction_addresses.each do |addr|
-        infos[addr] = from_root_instruction(program_file.instruction(addr))
-      end
-      infos
-    end
-
-    # Generates a {CallStackInfo} from the given root instruction.
-    # This will tell you the maximum value the call stack could get to for a
-    # program that starts at the given instruction with an empty call stack
-    # and never gets interrupted.
-    def self.from_root_instruction(root)
-      new(root)
-    end
-
-    # The maximum call stack depth for all the reachable instructions.
-    # If your program starts executing at the root node and the call stack
-    # is empty, then (not accounting for interrupts) the call stack will
-    # never exceed this depth.
-    #
-    # A value of 0 means that no subroutine calls a possible; a value of
-    # 1 means that at most one subroutine call is possible at any given time,
-    # and so on.
-    #
-    # @return (Integer)
-    attr_reader :max_depth
-
-    # @return (Instruction) The root instruction that this report was generated from.
-    attr_reader :root
-
-    # Generates a {CallStackInfo} from the given root instruction.
-    def initialize(root)
-      @root = root
-      generate
-      @max_depth = @max_depths.values.max
-    end
-
-    private
-
-    def generate
-      @max_depths = { @root => 0 }
-      @back_links = Hash.new { [] }
-      instructions_to_process = [root]
-      until instructions_to_process.empty?
-        instruction = instructions_to_process.pop
-        instruction.transitions.reverse_each do |transition|
-          ni = transition.next_instruction
-          prev_depth = @max_depths[ni]
-          new_depth = @max_depths[instruction] + transition.call_depth_change
-
-          if new_depth > 50
-            raise "Recursion probably detected.  Maximum call depth of #{ni} is at least #{new_depth}."
-          end
-
-          if prev_depth.nil? || new_depth > prev_depth
-            @max_depths[ni] = new_depth
-            instructions_to_process << ni
-            @back_links[ni] = []
-          end
-
-          if new_depth == @max_depths[ni]
-            @back_links[ni] << instruction
-          end
-        end
-      end
-    end
-
-    public
-
-    # Returns all the {Instruction}s that have the worse case possible call stack depth.
-    # @return [Array(Instruction)]
-    def instructions_with_worst_case
-      @max_depths.select { |instr, depth| depth == @max_depth }.map(&:first).sort
-    end
-
-    # Returns all the {Instruction}s that are reachable from the given root.
-    # @return [Array(Instruction)]
-    def reachable_instructions
-      @max_depths.keys
-    end
-
-    # Check the max-depth data hash for consistency.
-    def double_check!
-      reachable_instructions.each do |instr|
-        depth = @max_depths[instr]
-
-        instr.transitions.each do |transition|
-          next_instruction = transition.next_instruction
-          if @max_depths[next_instruction] < @max_depths[instr] + transition.call_depth_change
-            raise 'Call stack info double check failed: %s has max_depth %d and leads (%d) to %s with max_depth %d.' %
-              [instr, depth, transition.call_depth_change, next_instruction, @max_depths[next_instruction]]
-          end
-        end
-
-      end
-    end
-
-    # Returns an array of {CodePath}s representing all possible ways that the call stack
-    # could reach the worst-case depth.  This will often be a very large amount of data,
-    # even for a small project.
-    # @return [Array(CodePath)]
-    def worst_case_code_paths
-      instructions_with_worst_case.sort.flat_map do |instruction|
-        code_paths(instruction)
-      end
-    end
-
-    # Returns a filtered version of {#worst_case_code_paths}.
-    # Filters out any code paths that are just a superset of another code path.
-    # For each instruction that has a back trace leading to it, it just returns
-    # the code paths with the smallest number of interesting instructions.
-    # @return [Array(CodePath)]
-    def worst_case_code_paths_filtered
-      all_code_paths = worst_case_code_paths
-
-      # Filter out code path that are just a superset of another code path.
-      previously_seen_instruction_sequences = Set.new
-      code_paths = []
-      all_code_paths.sort_by(&:count).each do |code_path|
-        seen_before = (1..code_path.instructions.size).any? do |n|
-          subsequence = code_path.instructions[0, n]
-          previously_seen_instruction_sequences.include? subsequence
-        end
-        if !seen_before
-          previously_seen_instruction_sequences << code_path.instructions
-          code_paths << code_path
-        end
-      end
-
-      # For each instruction that has a code path leading to it, pick out
-      # the shortest code path (in terms of interesting instructions).
-      code_paths = code_paths.group_by { |cp| cp.instructions.last }.map do |instr, paths|
-        paths.min_by { |cp| cp.interesting_instructions.count }
-      end
-
-      code_paths
-    end
-
-    # Returns a nice report string of all the {#worst_case_code_paths_filtered}.
-    # @return [String]
-    def worst_case_code_paths_filtered_report
-      s = ''
-      worst_case_code_paths_filtered.each do |code_path|
-        s << code_path.to_s + "\n"
-        s << "\n"
-      end
-      s
-    end
-
-    # @return [Array(CodePaths)] all the possible code paths that lead to the given instruction.
-    def code_paths(instruction)
-      code_paths = []
-      Search.depth_first_search_simple([[instruction]]) do |instrs|
-        prev_instrs = @back_links[instrs.first]
-
-        if prev_instrs.empty?
-          # This must be the root node.
-          if instrs.first != @root
-            raise "This instruction is not the root and has no back links: #{instrs}."
-          end
-
-          code_paths << CodePath.new(instrs)
-          []   # don't search anything from this node
-        else
-          # Investigate all possible code paths that could get to this instruction.
-          # However, exclude code paths that have the same instruction twice;
-          # otherwise we get stuck in an infinite loop.
-          (prev_instrs - instrs).map do |instr|
-            [instr] + instrs
-          end
-        end
-      end
-      code_paths
-    end
-
-    def inspect
-      "#<#{self.class}:root=#{@root.inspect}>"
-    end
-
-    # This is a helper class for {CallStackInfo}.  It wraps an array of {Instruction} objects
-    # representing an execution path from one part of the program (usually the entry vector or
-    # the ISR vector) to another part of the program.
-    # It has method for reducing this list of instructions by only showing the interesting ones.
-    class CodePath
-      include Enumerable
-
-      # An array of {Instruction}s that represents a possible path through the program.
-      # Each instruction in the list could possibly execute after the previous one.
-      attr_reader :instructions
-
-      # A new instance that wraps the given instructions.
-      # @param instructions Array(Instruction) The instructions to wrap.
-      def initialize(instructions)
-        @instructions = instructions.freeze
-      end
-
-      # Iterates over the wrapped instructions by calling <tt>each</tt> on the underlying array.
-      # Since this class also includes <tt>Enumerable</tt>, it means you can use any of the
-      # usual methods of Enumerable (e.g. <tt>select</tt>) on this class.
-      def each(&proc)
-        instructions.each(&proc)
-      end
-
-      # Returns the addresses of the underlying instructions.
-      def addresses
-        instructions.map(&:address)
-      end
-
-      # Returns an array of the addresses of the interesting instructions.
-      def interesting_addresses
-        interesting_instructions.map(&:address)
-      end
-
-      # Returns just the interesting instructions, as defined by {#interesting_instruction?}.
-      #
-      # @return [Array(Integer)]
-      def interesting_instructions
-        @instructions.select.each_with_index do |instruction, index|
-          next_instruction = @instructions[index + 1]
-          interesting_instruction?(instruction, next_instruction)
-        end
-      end
-
-      # Returns true if the given instruction is interesting.  An instruction is
-      # interesting if you would need to see it in order to understand the path
-      # program has taken through the code and understand why the call stack
-      # could reach a certain depth.
-      #
-      # * The first and last instructions are interesting.
-      # * A branch that is taken is interesting.
-      # * A subroutine call is interesting.
-      def interesting_instruction?(instruction, next_instruction)
-        if instruction == @instructions.first || instruction == @instructions.last
-          return true
-        end
-
-        transition = instruction.transition_to(next_instruction)
-
-        if transition.call_depth_change >= 1
-          # This edge represents a function call so it is interesting.
-          return true
-        end
-
-        if transition.non_local?
-          # This edge represents a goto, so that is interesting
-          # because you need to know which gotos were taken to understand
-          # a code path.  If seeing the skip is annoying we could
-          # suppress that by adding more information to the edge.
-          return true
-        end
-
-        # Everything else is not interesting.
-
-        # We are purposing deciding that skips are not interesting.
-        # because if you are trying to understand the full code path
-        # it is obvious whether any given skip was taken or not, as long
-        # as you know which calls and gotos were taken.
-
-        false
-      end
-
-      # Returns a multi-line string representing this execution path.
-      def to_s
-        "CodePath:\n" +
-          interesting_instructions.join("\n") + "\n"
-      end
-    end
-  end
-end

data/lib/rpicsim/instruction.rb

@@ -1,337 +0,0 @@
-module RPicSim
-  # Instances of this class represent a particular instruction at a particular
-  # address in program memory.  This class takes low-level information about a
-  # disassembled instruction and produces high-level information about what that
-  # instruction is and how it behaves.
-  #
-  # Instances of this class have links to the other instructions that the instruction
-  # could lead to, so the instances form a graph.  This graph is traversed by
-  # classes like {CallStackInfo} to get useful information about the firmware.
-  class Instruction
-    include Comparable
-
-    # The program memory address of the instruction.
-    # For PIC18s this will be the byte address.
-    # For other PIC architectures, it will be the word address.
-    # @return (Integer)
-    attr_reader :address
-
-    # The opcode as a capitalized string (e.g. "MOVLW").
-    # @return (String)
-    attr_reader :opcode
-
-    # The operands of the instruction as a hash like { "k" => 92 }.
-    # @return (Hash)
-    attr_reader :operands
-
-    # The number of program memory address units that this instruction takes.
-    # The units of this are the same as the units of {#address}.
-    # @return (Integer)
-    attr_reader :size
-
-    # A line of assembly language that would represent this instruction.
-    # For example "GOTO 0x2".
-    # @return (String)
-    attr_reader :string
-
-    # Creates a new instruction.
-    def initialize(mplab_instruction, address, address_increment, instruction_store)
-      @address = address
-      @instruction_store = instruction_store
-      @address_increment = address_increment
-
-      if mplab_instruction == :invalid
-        @valid = false
-        @size = @address_increment
-        @string = '[INVALID]'
-        return
-      end
-
-      @valid = true
-      @opcode = mplab_instruction.opcode
-      @operands = mplab_instruction.operands
-      @string = mplab_instruction.instruction_string
-
-      @size = mplab_instruction.compute_size(address_increment)
-      raise "Invalid size #{@size} for #{inspect}" if ![1, 2, 4].include?(@size)
-
-      properties = Array case mplab_instruction.opcode
-      when 'ADDFSR'
-      when 'ADDLW'
-      when 'ADDWF'
-      when 'ADDWFC'
-      when 'ANDLW'
-      when 'ANDWF'
-      when 'ASRF'
-      when 'BC'     then [:conditional_relative_branch]
-      when 'BCF'
-      when 'BN'     then [:conditional_relative_branch]
-      when 'BNC'    then [:conditional_relative_branch]
-      when 'BNN'    then [:conditional_relative_branch]
-      when 'BNOV'   then [:conditional_relative_branch]
-      when 'BNZ'    then [:conditional_relative_branch]
-      when 'BRA'    then [:relative_branch]
-      when 'BRW'    then [:control_ender]    # Hard to predict
-      when 'BSF'
-      when 'BTG'
-      when 'BTFSC'  then [:conditional_skip]
-      when 'BTFSS'  then [:conditional_skip]
-      when 'BZ'     then [:conditional_relative_branch]
-      when 'CALL'   then [:call]
-      when 'CALLW'  then [:control_ender]    # Hard to predict
-      when 'CPFSEQ' then [:conditional_skip]
-      when 'CPFSGT' then [:conditional_skip]
-      when 'CPFSLT' then [:conditional_skip]
-      when 'CLRF'
-      when 'CLRW'
-      when 'CLRWDT'
-      when 'COMF'
-      when 'DAW'
-      when 'DECF'
-      when 'DECFSZ' then [:conditional_skip]
-      when 'DCFSNZ' then
-      when 'GOTO'   then [:goto]
-      when 'INCF'
-      when 'INCFSZ' then [:conditional_skip]
-      when 'INFSNZ' then [:conditional_skip]
-      when 'IORLW'
-      when 'IORWF'
-      when 'LFSR'
-      when 'LSLF'
-      when 'LSRF'
-      when 'MOVIW'
-      when 'MOVWI'
-      when 'MOVLB'
-      when 'MOVLP'
-      when 'MOVLW'
-      when 'MOVWF'
-      when 'MOVF'
-      when 'MOVFF'
-      when 'MULLW'
-      when 'MULWF'
-      when 'NEGF'
-      when 'NOP'
-      when 'OPTION'
-      when 'PUSH'
-      when 'POP'
-      when 'RCALL'  then [:relative_call]
-      when 'RESET'  then [:control_ender]
-      when 'RETFIE' then [:control_ender]
-      when 'RETLW'  then [:control_ender]
-      when 'RETURN' then [:control_ender]
-      when 'RLCF'
-      when 'RLF'
-      when 'RLNCF'
-      when 'RRCF'
-      when 'RRF'
-      when 'RRNCF'
-      when 'SETF'
-      when 'SLEEP'
-      when 'SUBLW'
-      when 'SUBWF'
-      when 'SUBWFB'
-      when 'SWAPF'
-      when 'TBLRD*'
-      when 'TBLRD*+'
-      when 'TBLRD*-'
-      when 'TBLRD+*'
-      when 'TBLWT*'
-      when 'TBLWT*+'
-      when 'TBLWT*-'
-      when 'TBLWT+*'
-      when 'TRIS'
-      when 'TSTFSZ' then [:conditional_skip]
-      when 'XORLW'
-      when 'XORWF'
-      else
-        raise "Unrecognized opcode #{mplab_instruction.opcode} " +
-          "(#{address_description(address)}, operands #{mplab_instruction.operands.inspect})."
-      end
-
-      modules = {
-        conditional_skip: ConditionalSkip,
-        conditional_relative_branch: ConditionalRelativeBranch,
-        relative_branch: RelativeBranch,
-        relative_call: RelativeCall,
-        goto: Goto,
-        control_ender: ControlEnder,
-        call: Call,
-      }
-
-      properties.each do |p|
-        mod = modules[p]
-        if !mod
-          raise ArgumentError, "Invalid property: #{p.inspect}."
-        end
-        extend mod
-      end
-    end
-
-    # Compares this instruction to another using the addresses.  This means you can
-    # call +.sort+ on an array of instructions to put them in order by address.
-    def <=>(other)
-      address <=> other.address
-    end
-
-    # Human-readable string representation of the instruction.
-    def to_s
-      "Instruction(#{@instruction_store.address_description(address)}, #{@string})"
-    end
-
-    def inspect
-      "#<#{self.class}:#{@instruction_store.address_description(address)}, #{@string}>"
-    end
-
-    # Returns info about all the instructions that this instruction could directly lead to
-    # (not counting interrupts, returns, and not accounting
-    # at all for what happens after the last word in the main program memory is executed).
-    # For instructions that pop from the call stack like RETURN and RETFIE, this will be
-    # the empty array.
-    # @return [Array(Transition)]
-    def transitions
-      @transitions ||= generate_transitions
-    end
-
-    # Returns the transition from this instruction to the specified instruction
-    # or nil if no such transition exists.
-    # @return Transition
-    def transition_to(instruction)
-      @transitions.find { |t| t.next_instruction == instruction }
-    end
-
-    # Returns the addresses of all the instructions this instruction could directly lead to.
-    # @return [Array(Integer)]
-    def next_addresses
-      transitions.map(&:next_address)
-    end
-
-    # Returns true if this is actually a valid instruction.  Invalid
-    # instructions can occur when disassembling bytes that are not actually
-    # instructions.
-    def valid?
-      @valid
-    end
-
-    private
-
-    # For certain opcodes, this method gets over-written.
-    def generate_transitions
-      [advance(1)]
-    end
-
-    # Makes a transition representing the default behavior: the microcontroller
-    # will increment the program counter and execute the next instruction in memory.
-    def advance(num)
-      transition(address + num * size)
-    end
-
-    def transition(addr, attrs = {})
-      Transition.new(self, addr, @instruction_store, attrs)
-    end
-
-    private
-
-    # Returns the address indicated by the operand 'k'.
-    # k is assumed to be a word address and it is assumed to be absolute
-    # k=0 is word 0 of memory, k=1 is word one.
-    # We need to multiply by the address increment because on PIC18
-    # program memory addresses are actually byte-based instead of word-based.
-    def k_address
-      operands[:k] * @address_increment
-    end
-
-    def n_address
-      address + @address_increment * (operands[:n] + 1)
-    end
-
-    def relative_k_address
-      address + @address_increment * (operands[:k] + 1)
-    end
-
-    def relative_target_address
-      if operands[:k]
-        relative_k_address
-      elsif operands[:n]
-        n_address
-      else
-        raise 'This instruction does not have fields k or n.'
-      end
-    end
-
-    ### Modules that modify the behavior of the instruction. ###
-
-    # This module is mixed into any {Instruction} that represents a goto or branch.
-    module Goto
-      def generate_transitions
-        # Assumption: The GOTO instruction's k operand is absolute on all architectures
-        [transition(k_address, non_local: true)]
-      end
-    end
-
-    # This module is mixed into any {Instruction} that represents a conditional skip
-    # A conditional skip is an instruction that might cause the next instruction to be
-    # skipped depending on some condition.
-    module ConditionalSkip
-      def generate_transitions
-        [advance(1), advance(2)]
-      end
-    end
-
-    # This module is mixed into any {Instruction} that represents a return from a subroutine
-    # or a RESET instruction.
-    module ControlEnder
-      def generate_transitions
-        []
-      end
-    end
-
-    # This module is mixed into any {Instruction} that represents a subroutine call.
-    module Call
-      def generate_transitions
-        [transition(k_address, call_depth_change: 1), advance(1)]
-      end
-    end
-
-    module RelativeCall
-      def generate_transitions
-        [transition(n_address, call_depth_change: 1), advance(1)]
-      end
-    end
-
-    module ConditionalRelativeBranch
-      def generate_transitions
-        [transition(n_address, non_local: true), advance(1)]
-      end
-    end
-
-    module RelativeBranch
-      def generate_transitions
-        [transition(relative_target_address, non_local: true)]
-      end
-    end
-
-    class Transition
-      attr_reader :previous_instruction
-      attr_reader :next_address
-
-      def initialize(previous_instruction, next_address, instruction_store, attrs)
-        @previous_instruction = previous_instruction
-        @next_address = next_address
-        @instruction_store = instruction_store
-        @attrs = attrs
-      end
-
-      def next_instruction
-        @next_instruction ||= @instruction_store.instruction(next_address)
-      end
-
-      def non_local?
-        @attrs.fetch(:non_local, false)
-      end
-
-      def call_depth_change
-        @attrs.fetch(:call_depth_change, 0)
-      end
-    end
-  end
-end