avruby 0.5.1

data/lib/avr/opcode/branch/conditional.rb

@@ -0,0 +1,61 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    parse_operands('____ __kk kkkk ksss') do |cpu, operands|
+      {
+        k: Value.new(twos_complement(operands.fetch(:k).value, 7)),
+        s: Value.new(operands.fetch(:s).value ? 1 : 0),
+      }
+    end
+
+    decode('1111 00kk kkkk ksss', :brbs) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:brbs, operands.fetch(:s), operands.fetch(:k))
+    end
+
+    opcode(:brbs, %i[sreg_flag near_relative_pc]) do |cpu, _memory, args|
+      cpu.next_pc = cpu.pc + args.fetch(1).value + 1 if args.fetch(0).value == 1
+    end
+
+    decode('1111 01kk kkkk ksss', :brbc) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:brbc, operands.fetch(:s), operands.fetch(:k))
+    end
+
+    opcode(:brbc, %i[sreg_flag near_relative_pc]) do |cpu, _memory, args|
+      cpu.next_pc = cpu.pc + args.fetch(1).value + 1 if args.fetch(0).value == 0
+    end
+
+    decode('0001 00rd dddd rrrr', :cpse) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:cpse, operands.fetch(:Rd), operands.fetch(:Rr))
+    end
+
+    opcode(:cpse, %i[register register]) do |cpu, _memory, args|
+      cpu.decode if args.fetch(0).value == args.fetch(1).value
+    end
+
+    decode('1111 110r rrrr 0bbb', :sbrc) do |cpu, _opcode_definition, operands|
+      register_bit = RegisterWithBitNumber.new(
+        T.cast(operands.fetch(:Rr), MemoryByteRegister),
+        operands.fetch(:b).value
+      )
+      cpu.instruction(:sbrc, register_bit)
+    end
+
+    opcode(:sbrc, %i[register_with_bit_number]) do |cpu, _memory, args|
+      cpu.decode if args.fetch(0).value == 0
+    end
+
+    decode('1111 111r rrrr 0bbb', :sbrs) do |cpu, _opcode_definition, operands|
+      register_bit = RegisterWithBitNumber.new(
+        T.cast(operands.fetch(:Rr), MemoryByteRegister),
+        operands.fetch(:b).value
+      )
+      cpu.instruction(:sbrs, register_bit)
+    end
+
+    opcode(:sbrs, %i[register_with_bit_number]) do |cpu, _memory, args|
+      cpu.decode if args.fetch(0).value == 1
+    end
+  end
+end

data/lib/avr/opcode/branch/return.rb

@@ -0,0 +1,23 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('1001 0101 0000 1000', :ret) do |cpu, _opcode_definition, _operands|
+      cpu.instruction(:ret)
+    end
+
+    opcode(:ret) do |cpu, _memory, _args|
+      cpu.next_pc = stack_pop_word(cpu)
+    end
+
+    decode('1001 0101 0001 1000', :reti) do |cpu, _opcode_definition, _operands|
+      cpu.instruction(:reti)
+    end
+
+    opcode(:reti, %i[], %i[I]) do |cpu, _memory, _args|
+      cpu.sreg.I = true
+      cpu.next_pc = stack_pop_word(cpu)
+    end
+  end
+end

data/lib/avr/opcode/branch/unconditional.rb

@@ -0,0 +1,74 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('1001 0100 0000 1100', :jmp) do |cpu, _opcode_definition, _operands|
+      k = cpu.fetch
+      cpu.instruction(:jmp, Value.new(k))
+    end
+
+    decode('1001 010k kkkk 110k', :jmp) do |cpu, _opcode_definition, operands|
+      k = cpu.fetch
+      cpu.instruction(:jmp, Value.new(operands.fetch(:k).value << 16 | k))
+    end
+
+    opcode(:jmp, %i[absolute_pc]) do |cpu, _memory, args|
+      cpu.next_pc = args.fetch(0).value
+    end
+
+    decode('1001 0100 0000 1110', :call) do |cpu, _opcode_definition, _operands|
+      k = cpu.fetch
+      cpu.instruction(:call, Value.new(k))
+    end
+
+    decode('1001 010k kkkk 111k', :call) do |cpu, _opcode_definition, operands|
+      k = cpu.fetch
+      cpu.instruction(:call, Value.new(operands.fetch(:k).value << 16 | k))
+    end
+
+    opcode(:call, %i[absolute_pc]) do |cpu, _memory, args|
+      stack_push_word(cpu, cpu.pc + 2)
+      cpu.next_pc = args.fetch(0).value
+    end
+
+    # rcall rjmp
+    parse_operands('____ kkkk kkkk kkkk') do |_cpu, operands|
+      { k: Value.new(twos_complement(operands.fetch(:k).value, 12)) }
+    end
+
+    decode('1100 kkkk kkkk kkkk', :rjmp) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:rjmp, operands.fetch(:k))
+    end
+
+    opcode(:rjmp, %i[far_relative_pc]) do |cpu, _memory, args|
+      cpu.next_pc = cpu.pc + args.fetch(0).value + 1
+    end
+
+    decode('1101 kkkk kkkk kkkk', :rcall) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:rcall, operands.fetch(:k))
+    end
+
+    opcode(:rcall, %i[far_relative_pc]) do |cpu, _memory, args|
+      stack_push_word(cpu, cpu.pc + 1)
+      cpu.next_pc = cpu.pc + args.fetch(0).value + 1
+    end
+
+    decode('1001 0100 0000 1001', :ijmp) do |cpu, _opcode_definition, _operands|
+      cpu.instruction(:ijmp)
+    end
+
+    opcode(:ijmp) do |cpu, _memory, _args|
+      cpu.next_pc = cpu.Z.value
+    end
+
+    decode('1001 0101 0000 1001', :icall) do |cpu, _opcode_definition, _operands|
+      cpu.instruction(:icall)
+    end
+
+    opcode(:icall) do |cpu, _memory, _args|
+      stack_push_word(cpu, cpu.pc + 1)
+      cpu.next_pc = cpu.Z.value
+    end
+  end
+end

data/lib/avr/opcode/break.rb

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

data/lib/avr/opcode/compare.rb

@@ -0,0 +1,66 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    # rubocop:disable Naming/MethodParameterName
+    # rubocop:disable Layout/SpaceAroundOperators
+    sig { params(cpu: CPU, r: Integer, rd: Integer, rr_k: Integer, mnemonic: Symbol).void }
+    def self.set_sreg_for_cp_cpi_cpc(cpu, r, rd, rr_k, mnemonic)
+      b7    = (1<<7)
+      r7    = (r  & b7) != 0
+      rd7   = (rd & b7) != 0
+      rr_k7 = (rr_k & b7) != 0
+      r3    = (r  & b7) != 0
+      rd3   = (rd & b7) != 0
+      rr_k3 = (rr_k & b7) != 0
+      n     = r7
+      v     = rd7 & rr_k7 & r7 | !rd7 & rr_k7 & r7
+      c     = !rd7 & rr_k7 | rr_k7 & r7 | r7 & !rd7
+      h     = !rd3 & rr_k3 | rr_k3 & r3 | r3 & !rd3
+
+      z = r.zero?
+      z = r.zero? ? cpu.sreg.Z : false if mnemonic == :cpc
+
+      cpu.sreg.from_h(
+        {
+          H: h,
+          S: n ^ v,
+          V: v,
+          N: n,
+          Z: z,
+          C: c,
+        }
+      )
+    end
+    # rubocop:enable Layout/SpaceAroundOperators
+    # rubocop:enable Naming/MethodParameterName
+
+    decode('0001 01rd dddd rrrr', :cp) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:cp, operands.fetch(:Rd), operands.fetch(:Rr))
+    end
+
+    opcode(:cp, %i[register register], %i[H S V N Z C]) do |cpu, _memory, args|
+      result = (args.fetch(0).value - args.fetch(1).value) & 0xff
+      set_sreg_for_cp_cpi_cpc(cpu, result, args.fetch(0).value, args.fetch(1).value, :cp)
+    end
+
+    decode('0000 01rd dddd rrrr', :cpc) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:cpc, operands.fetch(:Rd), operands.fetch(:Rr))
+    end
+
+    opcode(:cpc, %i[register register], %i[H S V N Z C]) do |cpu, _memory, args|
+      result = (args.fetch(0).value - args.fetch(1).value - (cpu.sreg.C ? 1 : 0)) & 0xff
+      set_sreg_for_cp_cpi_cpc(cpu, result, args.fetch(0).value, args.fetch(1).value, :cpc)
+    end
+
+    decode('0011 KKKK dddd KKKK', :cpi) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:cpi, operands.fetch(:Rd), operands.fetch(:K))
+    end
+
+    opcode(:cpi, %i[register byte], %i[H S V N Z C]) do |cpu, _memory, args|
+      result = (args.fetch(0).value - args.fetch(1).value) & 0xff
+      set_sreg_for_cp_cpi_cpc(cpu, result, args.fetch(0).value, args.fetch(1).value, :cpi)
+    end
+  end
+end

data/lib/avr/opcode/data/immediate.rb

@@ -0,0 +1,14 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('1110 KKKK dddd KKKK', :ldi) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ldi, operands.fetch(:Rd), operands.fetch(:K))
+    end
+
+    opcode(:ldi, %i[register byte]) do |_cpu, _memory, args|
+      args.fetch(0).value = args.fetch(1).value
+    end
+  end
+end

data/lib/avr/opcode/data/program.rb

@@ -0,0 +1,25 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('1001 0101 1100 1000', :lpm) do |cpu, _opcode_definition, _operands|
+      cpu.instruction(:lpm, cpu.r0, RegisterWithModification.new(cpu.Z))
+    end
+
+    decode('1001 000d dddd 0100', :lpm) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:lpm, operands.fetch(:Rd), RegisterWithModification.new(cpu.Z))
+    end
+
+    decode('1001 000d dddd 0101', :lpm) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:lpm, operands.fetch(:Rd), RegisterWithModification.new(cpu.Z, :post_increment))
+    end
+
+    opcode(:lpm, %i[register modifying_word_register]) do |cpu, _memory, args|
+      mwr = T.cast(args.fetch(1), RegisterWithModification)
+      mwr.register.value -= 1 if mwr.modification == :pre_decrement
+      args.fetch(0).value = cpu.device.flash.memory.fetch(mwr.register.value).value
+      mwr.register.value += 1 if mwr.modification == :post_increment
+    end
+  end
+end

data/lib/avr/opcode/data/sram.rb

@@ -0,0 +1,222 @@
+# typed: strict
+# frozen_string_literal: true
+
+module AVR
+  class Opcode
+    decode('1001 000d dddd 0000', :lds) do |cpu, _opcode_definition, operands|
+      k = cpu.fetch
+      cpu.instruction(:lds, operands.fetch(:Rd).value, k)
+    end
+
+    parse_operands('____ _kkk dddd kkkk') do |cpu, operands|
+      {
+        Rd: cpu.registers.fetch(operands.fetch(:d).value),
+        k: bit_jumble_for_lds_sts(operands.fetch(:k).value),
+      }
+    end
+
+    decode('1010 0kkk dddd kkkk', :lds) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:lds, operands.fetch(:Rd), operands.fetch(:k))
+    end
+
+    opcode(:lds, %i[register word]) do |cpu, _memory, args|
+      cpu.next_pc += 1
+      args.fetch(0).value = cpu.sram.memory.fetch(args.fetch(1).value).value
+    end
+
+    decode('1001 000d dddd 1100', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.X))
+    end
+
+    decode('1001 000d dddd 1101', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.X, :post_increment))
+    end
+
+    decode('1001 000d dddd 1110', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.X, :pre_decrement))
+    end
+
+    decode('1000 000d dddd 1000', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.Y))
+    end
+
+    decode('1001 000d dddd 1001', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.Y, :post_increment))
+    end
+
+    decode('1001 000d dddd 1010', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.Y, :pre_decrement))
+    end
+
+    decode('1000 000d dddd 0000', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.Z))
+    end
+
+    decode('1001 000d dddd 0001', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.Z, :post_increment))
+    end
+
+    decode('1001 000d dddd 0010', :ld) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ld, operands.fetch(:Rd), RegisterWithModification.new(cpu.Z, :pre_decrement))
+    end
+
+    opcode(:ld, %i[register modifying_word_register]) do |cpu, _memory, args|
+      mwr = T.cast(args.fetch(1), RegisterWithModification)
+      mwr.register.value -= 1 if mwr.modification == :pre_decrement
+      args.fetch(0).value = cpu.sram.memory.fetch(mwr.register.value).value
+      mwr.register.value += 1 if mwr.modification == :post_increment
+    end
+
+    parse_operands('__q_ qq_d dddd _qqq') do |cpu, operands|
+      {
+        Rd: cpu.registers.fetch(operands.fetch(:d).value),
+        q: operands.fetch(:q),
+      }
+    end
+
+    decode('10q0 qq0d dddd 1qqq', :ldd) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ldd, operands.fetch(:Rd), RegisterWithDisplacement.new(cpu.Y, operands.fetch(:q).value))
+    end
+
+    decode('10q0 qq0d dddd 0qqq', :ldd) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:ldd, operands.fetch(:Rd), RegisterWithDisplacement.new(cpu.Z, operands.fetch(:q).value))
+    end
+
+    opcode(:ldd, %i[register displaced_word_register]) do |cpu, _memory, args|
+      dwr = T.cast(args.fetch(1), RegisterWithDisplacement)
+      args.fetch(0).value = cpu.sram.memory.fetch(dwr.register.value + dwr.displacement).value
+    end
+
+    decode('1001 001r rrrr 0000', :sts) do |cpu, _opcode_definition, operands|
+      k = cpu.fetch
+      cpu.instruction(:sts, k, operands.fetch(:Rr))
+    end
+
+    parse_operands('____ _kkk rrrr kkkk') do |cpu, operands|
+      {
+        Rr: cpu.registers.fetch(operands.fetch(:r).value),
+        k: bit_jumble_for_lds_sts(operands.fetch(:k).value),
+      }
+    end
+
+    decode('1010 0kkk rrrr kkkk', :sts) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:sts, operands.fetch(:k), operands.fetch(:Rr))
+    end
+
+    opcode(:sts, %i[word register]) do |cpu, _memory, args|
+      cpu.next_pc += 1
+      cpu.sram.memory.fetch(args.fetch(0).value).value = args.fetch(1).value
+    end
+
+    decode('1001 001r rrrr 1100', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, cpu.X, operands.fetch(:Rr))
+    end
+
+    decode('1001 001r rrrr 1101', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, RegisterWithModification.new(cpu.X, :post_increment), operands.fetch(:Rr))
+    end
+
+    decode('1001 001r rrrr 1110', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, RegisterWithModification.new(cpu.X, :pre_decrement), operands.fetch(:Rr))
+    end
+
+    decode('1000 001r rrrr 1000', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, RegisterWithModification.new(cpu.Y), operands.fetch(:Rr))
+    end
+
+    decode('1001 001r rrrr 1001', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, RegisterWithModification.new(cpu.Y, :post_increment), operands.fetch(:Rr))
+    end
+
+    decode('1001 001r rrrr 1010', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, RegisterWithModification.new(cpu.Y, :pre_decrement), operands.fetch(:Rr))
+    end
+
+    decode('1000 001r rrrr 0000', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, RegisterWithModification.new(cpu.Z), operands.fetch(:Rr))
+    end
+
+    decode('1001 001r rrrr 0001', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, RegisterWithModification.new(cpu.Z, :post_increment), operands.fetch(:Rr))
+    end
+
+    decode('1001 001r rrrr 0010', :st) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:st, RegisterWithModification.new(cpu.Z, :pre_decrement), operands.fetch(:Rr))
+    end
+
+    opcode(:st, %i[modifying_word_register register]) do |cpu, _memory, args|
+      mwr = T.cast(args.fetch(0), RegisterWithModification)
+      mwr.register.value -= 1 if mwr.modification == :pre_decrement
+      cpu.sram.memory.fetch(mwr.register.value).value = args.fetch(1).value
+      mwr.register.value += 1 if mwr.modification == :post_increment
+    end
+
+    parse_operands('__q_ qq_r rrrr _qqq') do |cpu, operands|
+      {
+        Rr: cpu.registers.fetch(operands.fetch(:r).value),
+        q: operands.fetch(:q),
+      }
+    end
+
+    decode('10q0 qq1r rrrr 1qqq', :std) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:std, RegisterWithDisplacement.new(cpu.Y, operands.fetch(:q).value), operands.fetch(:Rr))
+    end
+
+    decode('10q0 qq1r rrrr 0qqq', :std) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:std, RegisterWithDisplacement.new(cpu.Z, operands.fetch(:q).value), operands.fetch(:Rr))
+    end
+
+    opcode(:std, %i[displaced_word_register register]) do |cpu, _memory, args|
+      dwr = T.cast(args.fetch(0), RegisterWithDisplacement)
+      cpu.sram.memory.fetch(dwr.register.value + dwr.displacement).value = args.fetch(1).value
+    end
+
+    sig { params(memory_byte: MemoryByte, register: Value, mnemonic: Symbol).void }
+    def self.exchange_memory_byte_with_register(memory_byte, register, mnemonic)
+      old_value = memory_byte.value
+      case mnemonic
+      when :xch
+        memory_byte.value = register.value
+      when :las
+        memory_byte.value = register.value | old_value
+      when :lac
+        memory_byte.value = (~register.value & old_value) & 0xff
+      when :lat
+        memory_byte.value = register.value ^ old_value
+      end
+      register.value = old_value
+    end
+
+    decode('1001 001r rrrr 0100', :xch) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:xch, operands.fetch(:Rr))
+    end
+
+    opcode(:xch, %i[register]) do |cpu, _memory, args|
+      exchange_memory_byte_with_register(cpu.sram.memory.fetch(cpu.Z.value), args.fetch(0), :xch)
+    end
+
+    decode('1001 001r rrrr 0101', :las) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:las, operands.fetch(:Rr))
+    end
+
+    opcode(:las, %i[register]) do |cpu, _memory, args|
+      exchange_memory_byte_with_register(cpu.sram.memory.fetch(cpu.Z.value), args.fetch(0), :las)
+    end
+
+    decode('1001 001r rrrr 0110', :lac) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:lac, operands.fetch(:Rr))
+    end
+
+    opcode(:lac, %i[register]) do |cpu, _memory, args|
+      exchange_memory_byte_with_register(cpu.sram.memory.fetch(cpu.Z.value), args.fetch(0), :lac)
+    end
+
+    decode('1001 001r rrrr 0111', :lat) do |cpu, _opcode_definition, operands|
+      cpu.instruction(:lat, operands.fetch(:Rr))
+    end
+
+    opcode(:lat, %i[register]) do |cpu, _memory, args|
+      exchange_memory_byte_with_register(cpu.sram.memory.fetch(cpu.Z.value), T.cast(args.fetch(0), Register), :lat)
+    end
+  end
+end