avruby 0.5.1

data/lib/avr/opcode/nop.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('0000 0000 0000 0000', :nop) do |cpu, _opcode_definition, _operands|
+      cpu.instruction(:nop)
+    end
+
+    opcode(:nop) do |_cpu, _memory, _args|
+      # Do nothing.
+    end
+  end
+end

data/lib/avr/opcode/opcodes.rb

@@ -0,0 +1,24 @@
+# typed: strict
+# frozen_string_literal: true
+
+require 'avr/opcode/operand_parsers'
+require 'avr/opcode/nop'
+require 'avr/opcode/break'
+require 'avr/opcode/sleep'
+require 'avr/opcode/wdr'
+require 'avr/opcode/sreg'
+require 'avr/opcode/register'
+require 'avr/opcode/compare'
+require 'avr/opcode/data/stack'
+require 'avr/opcode/data/immediate'
+require 'avr/opcode/data/program'
+require 'avr/opcode/data/sram'
+require 'avr/opcode/branch/unconditional'
+require 'avr/opcode/branch/conditional'
+require 'avr/opcode/branch/return'
+require 'avr/opcode/math/addition'
+require 'avr/opcode/math/subtraction'
+require 'avr/opcode/math/multiplication'
+require 'avr/opcode/math/bitwise'
+require 'avr/opcode/io/bit'
+require 'avr/opcode/io/in_out'

data/lib/avr/opcode/operand_parsers.rb

@@ -0,0 +1,75 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    sig { params(value: Integer, bits: Integer).returns(Integer) }
+    def self.twos_complement(value, bits)
+      mask = (2**(bits - 1)).to_i
+      -(value & mask) + (value & ~mask)
+    end
+
+    sig { params(k_in: Integer).returns(Integer) }
+    def self.bit_jumble_for_lds_sts(k_in)
+      k_out  = k_in & 0b00001111
+      k_out |= k_in & 0b01100000 >> 1
+      k_out |= k_in & 0b00010000 << 2
+      k_out |= ~(k_in & 0b00010000 << 3) & 0b10000000
+      k_out
+    end
+
+    # adc add and cp cpc cpse eor mov mul muls or sbc sub
+    parse_operands('____ __rd dddd rrrr') do |cpu, operands|
+      {
+        Rd: cpu.registers.fetch(operands.fetch(:d).value),
+        Rr: cpu.registers.fetch(operands.fetch(:r).value),
+      }
+    end
+
+    # fmul fmuls fmulsu mulsu
+    parse_operands('____ ____ _ddd _rrr') do |cpu, operands|
+      {
+        Rd: cpu.registers.fetch(operands.fetch(:d).value | 0b10000),
+        Rr: cpu.registers.fetch(operands.fetch(:r).value | 0b10000),
+      }
+    end
+
+    # asr com dec elpm inc ld lds lpm lsr neg pop ror swap
+    parse_operands('____ ___d dddd ____') do |cpu, operands|
+      {
+        Rd: cpu.registers.fetch(operands.fetch(:d).value),
+      }
+    end
+
+    # lac las lat push st xch
+    parse_operands('____ ___r rrrr ____') do |cpu, operands|
+      {
+        Rr: cpu.registers.fetch(operands.fetch(:r).value),
+      }
+    end
+
+    # sbrc sbrs
+    parse_operands('____ ___r rrrr _bbb') do |cpu, operands|
+      {
+        Rr: cpu.registers.fetch(operands.fetch(:r).value),
+        b: Value.new(operands.fetch(:b).value),
+      }
+    end
+
+    # adiw sbiw
+    parse_operands('____ ____ KKdd KKKK') do |cpu, operands|
+      {
+        Rd: cpu.registers.associated_word_register(cpu.registers.fetch((operands.fetch(:d).value << 1) | 0b11000)),
+        K: Value.new(operands.fetch(:K).value),
+      }
+    end
+
+    # andi cpi ldi ori sbci sbr subi
+    parse_operands('____ KKKK dddd KKKK') do |cpu, operands|
+      {
+        Rd: cpu.registers.fetch(operands.fetch(:d).value | 0b10000),
+        K: Value.new(operands.fetch(:K).value),
+      }
+    end
+  end
+end

data/lib/avr/opcode/register.rb

@@ -0,0 +1,37 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('0010 11rd dddd rrrr', :mov) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:mov, operands.fetch(:Rd), operands.fetch(:Rr))
+    end
+
+    opcode(:mov, %i[register register]) do |_cpu, _memory, args|
+      args.fetch(0).value = args.fetch(1).value
+    end
+
+    parse_operands('____ ____ dddd rrrr') do |cpu, operands|
+      {
+        Rd: RegisterPair.new(
+          cpu,
+          cpu.registers.fetch((operands.fetch(:d).value << 1) + 1),
+          cpu.registers.fetch(operands.fetch(:d).value << 1)
+        ),
+        Rr: RegisterPair.new(
+          cpu,
+          cpu.registers.fetch((operands.fetch(:r).value << 1) + 1),
+          cpu.registers.fetch(operands.fetch(:r).value << 1)
+        ),
+      }
+    end
+
+    decode('0000 0001 dddd rrrr', :movw) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:movw, operands.fetch(:Rd), operands.fetch(:Rr))
+    end
+
+    opcode(:movw, %i[register_pair register_pair]) do |_cpu, _memory, args|
+      args.fetch(0).value = args.fetch(1).value
+    end
+  end
+end

data/lib/avr/opcode/sleep.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('1001 0101 1000 1000', :sleep) do |cpu, _opcode_definition, _operands|
+      cpu.instruction(:sleep)
+    end
+
+    opcode(:sleep) do |cpu, memory, args|
+      # Do nothing.
+    end
+  end
+end

data/lib/avr/opcode/sreg.rb

@@ -0,0 +1,56 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('1001 0100 0sss 1000', :bset) do |cpu, _opcode_definition, operands|
+      sreg_bit = RegisterWithNamedBit.new(
+        cpu.sreg,
+        SREG::STATUS_BITS.fetch(operands.fetch(:s).value)
+      )
+      cpu.instruction(:bset, sreg_bit)
+    end
+
+    opcode(:bset, %i[sreg_flag], %i[I T H S V N Z C]) do |cpu, _memory, args|
+      args.fetch(0).value = 1
+    end
+
+    decode('1001 0100 1sss 1000', :bclr) do |cpu, _opcode_definition, operands|
+      sreg_bit = RegisterWithNamedBit.new(
+        cpu.sreg,
+        SREG::STATUS_BITS.fetch(operands.fetch(:s).value)
+      )
+      cpu.instruction(:bclr, sreg_bit)
+    end
+
+    opcode(:bclr, %i[sreg_flag], %i[I T H S V N Z C]) do |cpu, _memory, args|
+      args.fetch(0).value = 0
+    end
+
+    parse_operands('____ ___d dddd _bbb') do |cpu, operands|
+      {
+        Rd: cpu.registers.fetch(operands.fetch(:d).value),
+        b: operands.fetch(:b),
+      }
+    end
+
+    decode('1111 100d dddd 0bbb', :bld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:bld, operands.fetch(:Rd), operands.fetch(:b))
+    end
+
+    opcode(:bld, %i[register bit_number]) do |cpu, _memory, args|
+      t_bit   = 1 << args.fetch(1).value
+      t_value = cpu.sreg.T ? t_bit : 0
+      t_mask  = ~t_bit & 0xff
+      args.fetch(0).value = (args.fetch(0).value & t_mask) | t_value
+    end
+
+    decode('1111 101d dddd 0bbb', :bst) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:bst, operands.fetch(:Rd), operands.fetch(:b))
+    end
+
+    opcode(:bst, %i[register bit_number], %i[T]) do |cpu, _memory, args|
+      cpu.sreg.T = args.fetch(0).value & (1 << args.fetch(1).value) != 0
+    end
+  end
+end

data/lib/avr/opcode/wdr.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('1001 0101 1010 1000', :wdr) do |cpu, _opcode_definition, _operands|
+      cpu.instruction(:wdr)
+    end
+
+    opcode(:wdr) do |_cpu, _memory, _args|
+      # Do nothing for now.
+    end
+  end
+end

data/lib/avr/opcode_decoder.rb

@@ -0,0 +1,202 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class OpcodeDecoder
+    extend T::Sig
+
+    class OpcodeDefinition
+      extend T::Sig
+
+      ProcType = T.type_alias do
+        T.proc.params(
+          cpu: CPU,
+          opcode_definition: OpcodeDefinition,
+          operands: Opcode::OperandValueHashType
+        ).returns(Instruction)
+      end
+
+      sig { returns(String) }
+      attr_reader :pattern
+
+      sig { returns(Symbol) }
+      attr_reader :mnemonic
+
+      sig { returns(ProcType) }
+      attr_reader :parse_proc
+
+      sig { params(pattern: String, mnemonic: Symbol, parse_proc: ProcType).void }
+      def initialize(pattern, mnemonic, parse_proc)
+        @pattern = T.let(pattern.gsub(/[^01a-zA-Z]/, ''), String)
+        raise "Incorrect pattern length for #{pattern}" unless @pattern.size == 16
+
+        @mnemonic = mnemonic
+        @parse_proc = parse_proc
+
+        @operand_pattern = T.let(nil, T.nilable(String))
+        @match_value = T.let(nil, T.nilable(Integer))
+        @match_mask = T.let(nil, T.nilable(Integer))
+      end
+
+      sig { returns(String) }
+      def operand_pattern
+        @operand_pattern ||= pattern.gsub(/[01]/, '_')
+      end
+
+      sig { returns(Integer) }
+      def match_value
+        @match_value ||= pattern.gsub(/[^01]/, '0').to_i(2)
+      end
+
+      sig { returns(Integer) }
+      def match_mask
+        @match_mask ||= pattern.gsub(/[01]/, '1').gsub(/[^01]/, '0').to_i(2)
+      end
+
+      sig { params(word: Integer).returns(T::Boolean) }
+      def match?(word)
+        word & match_mask == match_value
+      end
+
+      sig { params(word: Integer).returns(Argument::NamedValueType) }
+      def extract_operands(word)
+        operands = Hash.new(0)
+        mask = 0x10000
+        pattern.split('').each do |operand|
+          mask >>= 1
+          next if %w[0 1].include?(operand)
+
+          operands[operand.to_sym] <<= 1
+          operands[operand.to_sym] |= 1 if (word & mask) != 0
+        end
+        operands.each_with_object({}) { |(k, v), h| h[k] = Value.new(v) }
+      end
+
+      sig do
+        params(
+          cpu: CPU,
+          opcode_definition: OpcodeDefinition,
+          operands: Argument::NamedValueType
+        ).returns(Instruction)
+      end
+      def parse(cpu, opcode_definition, operands)
+        parse_proc.call(cpu, opcode_definition, operands)
+      end
+    end
+
+    class OperandParser
+      extend T::Sig
+
+      sig { returns(String) }
+      attr_reader :pattern
+
+      ProcType = T.type_alias do
+        T.proc.params(cpu: CPU, operands: Opcode::OperandValueHashType).returns(Opcode::OperandValueHashType)
+      end
+
+      sig { returns(OperandParser::ProcType) }
+      attr_reader :parse_proc
+
+      sig { params(pattern: String, parse_proc: OperandParser::ProcType).void }
+      def initialize(pattern, parse_proc)
+        @pattern = T.let(pattern.gsub(/[^01a-zA-Z_]/, ''), String)
+        @parse_proc = T.let(parse_proc, OperandParser::ProcType)
+      end
+
+      sig { params(cpu: CPU, operands: Opcode::OperandValueHashType).returns(Opcode::OperandValueHashType) }
+      def parse(cpu, operands)
+        parse_proc.call(cpu, operands)
+      end
+    end
+
+    class DecodedOpcode
+      extend T::Sig
+
+      sig { returns(OpcodeDefinition) }
+      attr_reader :opcode_definition
+
+      sig { returns(Opcode::OperandValueHashType) }
+      attr_reader :operands
+
+      sig { params(opcode_definition: OpcodeDefinition, operands: Opcode::OperandValueHashType).void }
+      def initialize(opcode_definition, operands)
+        @opcode_definition = opcode_definition
+        @operands = operands
+      end
+
+      sig { params(cpu: CPU).returns(Opcode::OperandValueHashType) }
+      def prepare_operands(cpu)
+        parser = OpcodeDecoder.operand_parsers[opcode_definition.operand_pattern]
+        parser&.parse(cpu, operands) || operands
+      end
+    end
+
+    @opcode_definitions = T.let([], T::Array[OpcodeDefinition])
+    @opcode_match_masks = T.let({}, T::Hash[Integer, T::Hash[Integer, OpcodeDefinition]])
+    @operand_parsers = T.let({}, T::Hash[String, OpcodeDecoder::OperandParser])
+
+    class << self
+      extend T::Sig
+
+      sig { returns(T::Array[OpcodeDefinition]) }
+      attr_reader :opcode_definitions
+
+      sig { returns(T::Hash[Integer, T::Hash[Integer, OpcodeDefinition]]) }
+      attr_reader :opcode_match_masks
+
+      sig { returns(T::Hash[String, OpcodeDecoder::OperandParser]) }
+      attr_reader :operand_parsers
+    end
+
+    sig { params(opcode_definition: OpcodeDefinition).void }
+    def self.add_opcode_definition(opcode_definition)
+      opcode_definitions << opcode_definition
+      opcode_match_masks[opcode_definition.match_mask] ||= {}
+      opcode_match_masks.fetch(opcode_definition.match_mask)[opcode_definition.match_value] = opcode_definition
+    end
+
+    sig { params(operand_parser: OperandParser).void }
+    def self.add_operand_parser(operand_parser)
+      operand_parsers[operand_parser.pattern] = operand_parser
+    end
+
+    sig { returns(T::Hash[Integer, DecodedOpcode]) }
+    attr_reader :cache
+
+    sig { void }
+    def initialize
+      @cache = T.let({}, T::Hash[Integer, DecodedOpcode])
+    end
+
+    sig { params(word: Integer).returns(T.nilable(DecodedOpcode)) }
+    def decode(word)
+      cached_decoded_opcode = cache[word]
+      return cached_decoded_opcode if cached_decoded_opcode
+
+      OpcodeDecoder.opcode_match_masks.each do |mask, values|
+        opcode_definition = values[word & mask]
+        next unless opcode_definition
+
+        operands = opcode_definition.extract_operands(word)
+        decoded_opcode = DecodedOpcode.new(opcode_definition, operands)
+        cache[word] = decoded_opcode
+        return decoded_opcode
+      end
+      nil
+    end
+
+    sig { void }
+    def print_cache
+      puts "Opcode decoder cache (#{cache.size} opcodes cached):"
+      cache.sort.each do |word, decoded_opcode|
+        puts '  %04x = %17s = %-6s (%s)' % [
+          word,
+          word.to_s(2).rjust(16, '0').split('').each_slice(8).map(&:join).join(' '),
+          decoded_opcode.opcode_definition.mnemonic,
+          decoded_opcode.operands.map { |k, v| '%s = %5d' % [k, v] }.join(', '),
+        ]
+      end
+      nil
+    end
+  end
+end

data/lib/avr/oscillator.rb

@@ -0,0 +1,33 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Oscillator < Clock
+    extend T::Sig
+
+    sig { returns(T::Enumerator[TrueClass]) }
+    def infinite
+      [true].cycle
+    end
+
+    sig { params(time: T.any(Float, Integer)).returns(T::Enumerator[T.untyped]) }
+    def time_limit(time)
+      Enumerator.new do |y|
+        end_time = Time.now.to_f + time
+        y << true while Time.now.to_f < end_time
+      end
+    end
+
+    sig { params(limit: T::Enumerator[T.untyped]).returns(Integer) }
+    def run(limit = infinite)
+      start_ticks = ticks
+      limit.each { tick }
+      ticks - start_ticks
+    end
+
+    sig { params(time: T.any(Float, Integer)).returns(Integer) }
+    def run_timed(time)
+      run(time_limit(time))
+    end
+  end
+end