amaterasu 0.6.0

data/lib/amaterasu/game_boy/cpu/instructions.rb

@@ -0,0 +1,600 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/MethodLength, Metrics/ModuleLength
+module Amaterasu
+  module GameBoy
+    class Cpu
+      # Responsible to group all instruction types and load the CPU instructions array.
+      module Instructions
+        def self.load_base_instructions(cpu:)
+          instructions = Array.new(256)
+
+          # Opcodes 0x00 - 0x0F
+          instructions[0x00] = Nop.new(cpu:)
+          instructions[0x01] = Ld16.new(cpu:, target: :bc, source: :imm16)
+          instructions[0x02] = Ld8.new(cpu:, target: :mem_bc, source: :a)
+          instructions[0x03] = Inc.new(cpu:, operand: :bc)
+          instructions[0x04] = Inc.new(cpu:, operand: :b)
+          instructions[0x05] = Dec.new(cpu:, operand: :b)
+          instructions[0x06] = Ld8.new(cpu:, target: :b, source: :imm8)
+          instructions[0x07] = Rotate.new(cpu:, operation: :rlca)
+          instructions[0x08] = Ld16.new(cpu:, target: :mem_imm16, source: :sp)
+          instructions[0x09] = Add16.new(cpu:, target: :hl, source: :bc)
+          instructions[0x0A] = Ld8.new(cpu:, target: :a, source: :mem_bc)
+          instructions[0x0B] = Dec.new(cpu:, operand: :bc)
+          instructions[0x0C] = Inc.new(cpu:, operand: :c)
+          instructions[0x0D] = Dec.new(cpu:, operand: :c)
+          instructions[0x0E] = Ld8.new(cpu:, target: :c, source: :imm8)
+          instructions[0x0F] = Rotate.new(cpu:, operation: :rrca)
+
+          # Opcodes 0x10 - 0x1F
+          instructions[0x10] = Stop.new(cpu:)
+          instructions[0x11] = Ld16.new(cpu:, target: :de, source: :imm16)
+          instructions[0x12] = Ld8.new(cpu:, target: :mem_de, source: :a)
+          instructions[0x13] = Inc.new(cpu:, operand: :de)
+          instructions[0x14] = Inc.new(cpu:, operand: :d)
+          instructions[0x15] = Dec.new(cpu:, operand: :d)
+          instructions[0x16] = Ld8.new(cpu:, target: :d, source: :imm8)
+          instructions[0x17] = Rotate.new(cpu:, operation: :rla)
+          instructions[0x18] = Jr.new(cpu:)
+          instructions[0x19] = Add16.new(cpu:, target: :hl, source: :de)
+          instructions[0x1A] = Ld8.new(cpu:, target: :a, source: :mem_de)
+          instructions[0x1B] = Dec.new(cpu:, operand: :de)
+          instructions[0x1C] = Inc.new(cpu:, operand: :e)
+          instructions[0x1D] = Dec.new(cpu:, operand: :e)
+          instructions[0x1E] = Ld8.new(cpu:, target: :e, source: :imm8)
+          instructions[0x1F] = Rotate.new(cpu:, operation: :rra)
+
+          # Opcodes 0x20 - 0x2F
+          instructions[0x20] = Jr.new(cpu:, condition: :nz)
+          instructions[0x21] = Ld16.new(cpu:, target: :hl, source: :imm16)
+          instructions[0x22] = Ld8.new(cpu:, target: :mem_hli, source: :a)
+          instructions[0x23] = Inc.new(cpu:, operand: :hl)
+          instructions[0x24] = Inc.new(cpu:, operand: :h)
+          instructions[0x25] = Dec.new(cpu:, operand: :h)
+          instructions[0x26] = Ld8.new(cpu:, target: :h, source: :imm8)
+          instructions[0x27] = Daa.new(cpu:)
+          instructions[0x28] = Jr.new(cpu:, condition: :z)
+          instructions[0x29] = Add16.new(cpu:, target: :hl, source: :hl)
+          instructions[0x2A] = Ld8.new(cpu:, target: :a, source: :mem_hli)
+          instructions[0x2B] = Dec.new(cpu:, operand: :hl)
+          instructions[0x2C] = Inc.new(cpu:, operand: :l)
+          instructions[0x2D] = Dec.new(cpu:, operand: :l)
+          instructions[0x2E] = Ld8.new(cpu:, target: :l, source: :imm8)
+          instructions[0x2F] = Misc.new(cpu:, operation: :cpl)
+
+          # Opcodes 0x30 - 0x3F
+          instructions[0x30] = Jr.new(cpu:, condition: :nc)
+          instructions[0x31] = Ld16.new(cpu:, target: :sp, source: :imm16)
+          instructions[0x32] = Ld8.new(cpu:, target: :mem_hld, source: :a)
+          instructions[0x33] = Inc.new(cpu:, operand: :sp)
+          instructions[0x34] = Inc.new(cpu:, operand: :mem_hl)
+          instructions[0x35] = Dec.new(cpu:, operand: :mem_hl)
+          instructions[0x36] = Ld8.new(cpu:, target: :mem_hl, source: :imm8)
+          instructions[0x37] = Misc.new(cpu:, operation: :scf)
+          instructions[0x38] = Jr.new(cpu:, condition: :c)
+          instructions[0x39] = Add16.new(cpu:, target: :hl, source: :sp)
+          instructions[0x3A] = Ld8.new(cpu:, target: :a, source: :mem_hld)
+          instructions[0x3B] = Dec.new(cpu:, operand: :sp)
+          instructions[0x3C] = Inc.new(cpu:, operand: :a)
+          instructions[0x3D] = Dec.new(cpu:, operand: :a)
+          instructions[0x3E] = Ld8.new(cpu:, target: :a, source: :imm8)
+          instructions[0x3F] = Misc.new(cpu:, operation: :ccf)
+
+          # Opcodes 0x40 - 0x4F
+          instructions[0x40] = Ld8.new(cpu:, target: :b, source: :b)
+          instructions[0x41] = Ld8.new(cpu:, target: :b, source: :c)
+          instructions[0x42] = Ld8.new(cpu:, target: :b, source: :d)
+          instructions[0x43] = Ld8.new(cpu:, target: :b, source: :e)
+          instructions[0x44] = Ld8.new(cpu:, target: :b, source: :h)
+          instructions[0x45] = Ld8.new(cpu:, target: :b, source: :l)
+          instructions[0x46] = Ld8.new(cpu:, target: :b, source: :mem_hl)
+          instructions[0x47] = Ld8.new(cpu:, target: :b, source: :a)
+          instructions[0x48] = Ld8.new(cpu:, target: :c, source: :b)
+          instructions[0x49] = Ld8.new(cpu:, target: :c, source: :c)
+          instructions[0x4A] = Ld8.new(cpu:, target: :c, source: :d)
+          instructions[0x4B] = Ld8.new(cpu:, target: :c, source: :e)
+          instructions[0x4C] = Ld8.new(cpu:, target: :c, source: :h)
+          instructions[0x4D] = Ld8.new(cpu:, target: :c, source: :l)
+          instructions[0x4E] = Ld8.new(cpu:, target: :c, source: :mem_hl)
+          instructions[0x4F] = Ld8.new(cpu:, target: :c, source: :a)
+
+          # Opcodes 0x50 - 0x5F
+          instructions[0x50] = Ld8.new(cpu:, target: :d, source: :b)
+          instructions[0x51] = Ld8.new(cpu:, target: :d, source: :c)
+          instructions[0x52] = Ld8.new(cpu:, target: :d, source: :d)
+          instructions[0x53] = Ld8.new(cpu:, target: :d, source: :e)
+          instructions[0x54] = Ld8.new(cpu:, target: :d, source: :h)
+          instructions[0x55] = Ld8.new(cpu:, target: :d, source: :l)
+          instructions[0x56] = Ld8.new(cpu:, target: :d, source: :mem_hl)
+          instructions[0x57] = Ld8.new(cpu:, target: :d, source: :a)
+          instructions[0x58] = Ld8.new(cpu:, target: :e, source: :b)
+          instructions[0x59] = Ld8.new(cpu:, target: :e, source: :c)
+          instructions[0x5A] = Ld8.new(cpu:, target: :e, source: :d)
+          instructions[0x5B] = Ld8.new(cpu:, target: :e, source: :e)
+          instructions[0x5C] = Ld8.new(cpu:, target: :e, source: :h)
+          instructions[0x5D] = Ld8.new(cpu:, target: :e, source: :l)
+          instructions[0x5E] = Ld8.new(cpu:, target: :e, source: :mem_hl)
+          instructions[0x5F] = Ld8.new(cpu:, target: :e, source: :a)
+
+          # Opcodes 0x60 - 0x6F
+          instructions[0x60] = Ld8.new(cpu:, target: :h, source: :b)
+          instructions[0x61] = Ld8.new(cpu:, target: :h, source: :c)
+          instructions[0x62] = Ld8.new(cpu:, target: :h, source: :d)
+          instructions[0x63] = Ld8.new(cpu:, target: :h, source: :e)
+          instructions[0x64] = Ld8.new(cpu:, target: :h, source: :h)
+          instructions[0x65] = Ld8.new(cpu:, target: :h, source: :l)
+          instructions[0x66] = Ld8.new(cpu:, target: :h, source: :mem_hl)
+          instructions[0x67] = Ld8.new(cpu:, target: :h, source: :a)
+          instructions[0x68] = Ld8.new(cpu:, target: :l, source: :b)
+          instructions[0x69] = Ld8.new(cpu:, target: :l, source: :c)
+          instructions[0x6A] = Ld8.new(cpu:, target: :l, source: :d)
+          instructions[0x6B] = Ld8.new(cpu:, target: :l, source: :e)
+          instructions[0x6C] = Ld8.new(cpu:, target: :l, source: :h)
+          instructions[0x6D] = Ld8.new(cpu:, target: :l, source: :l)
+          instructions[0x6E] = Ld8.new(cpu:, target: :l, source: :mem_hl)
+          instructions[0x6F] = Ld8.new(cpu:, target: :l, source: :a)
+
+          # Opcodes 0x70 - 0x7F
+          instructions[0x70] = Ld8.new(cpu:, target: :mem_hl, source: :b)
+          instructions[0x71] = Ld8.new(cpu:, target: :mem_hl, source: :c)
+          instructions[0x72] = Ld8.new(cpu:, target: :mem_hl, source: :d)
+          instructions[0x73] = Ld8.new(cpu:, target: :mem_hl, source: :e)
+          instructions[0x74] = Ld8.new(cpu:, target: :mem_hl, source: :h)
+          instructions[0x75] = Ld8.new(cpu:, target: :mem_hl, source: :l)
+          instructions[0x76] = Halt.new(cpu:)
+          instructions[0x77] = Ld8.new(cpu:, target: :mem_hl, source: :a)
+          instructions[0x78] = Ld8.new(cpu:, target: :a, source: :b)
+          instructions[0x79] = Ld8.new(cpu:, target: :a, source: :c)
+          instructions[0x7A] = Ld8.new(cpu:, target: :a, source: :d)
+          instructions[0x7B] = Ld8.new(cpu:, target: :a, source: :e)
+          instructions[0x7C] = Ld8.new(cpu:, target: :a, source: :h)
+          instructions[0x7D] = Ld8.new(cpu:, target: :a, source: :l)
+          instructions[0x7E] = Ld8.new(cpu:, target: :a, source: :mem_hl)
+          instructions[0x7F] = Ld8.new(cpu:, target: :a, source: :a)
+
+          # Opcodes 0x80 - 0x8F
+          instructions[0x80] = Add8.new(cpu:, source: :b)
+          instructions[0x81] = Add8.new(cpu:, source: :c)
+          instructions[0x82] = Add8.new(cpu:, source: :d)
+          instructions[0x83] = Add8.new(cpu:, source: :e)
+          instructions[0x84] = Add8.new(cpu:, source: :h)
+          instructions[0x85] = Add8.new(cpu:, source: :l)
+          instructions[0x86] = Add8.new(cpu:, source: :mem_hl)
+          instructions[0x87] = Add8.new(cpu:, source: :a)
+          instructions[0x88] = Adc.new(cpu:, source: :b)
+          instructions[0x89] = Adc.new(cpu:, source: :c)
+          instructions[0x8A] = Adc.new(cpu:, source: :d)
+          instructions[0x8B] = Adc.new(cpu:, source: :e)
+          instructions[0x8C] = Adc.new(cpu:, source: :h)
+          instructions[0x8D] = Adc.new(cpu:, source: :l)
+          instructions[0x8E] = Adc.new(cpu:, source: :mem_hl)
+          instructions[0x8F] = Adc.new(cpu:, source: :a)
+
+          # Opcodes 0x90 - 0x9F
+          instructions[0x90] = Sub.new(cpu:, source: :b)
+          instructions[0x91] = Sub.new(cpu:, source: :c)
+          instructions[0x92] = Sub.new(cpu:, source: :d)
+          instructions[0x93] = Sub.new(cpu:, source: :e)
+          instructions[0x94] = Sub.new(cpu:, source: :h)
+          instructions[0x95] = Sub.new(cpu:, source: :l)
+          instructions[0x96] = Sub.new(cpu:, source: :mem_hl)
+          instructions[0x97] = Sub.new(cpu:, source: :a)
+          instructions[0x98] = Sbc.new(cpu:, source: :b)
+          instructions[0x99] = Sbc.new(cpu:, source: :c)
+          instructions[0x9A] = Sbc.new(cpu:, source: :d)
+          instructions[0x9B] = Sbc.new(cpu:, source: :e)
+          instructions[0x9C] = Sbc.new(cpu:, source: :h)
+          instructions[0x9D] = Sbc.new(cpu:, source: :l)
+          instructions[0x9E] = Sbc.new(cpu:, source: :mem_hl)
+          instructions[0x9F] = Sbc.new(cpu:, source: :a)
+
+          # Opcodes 0xA0 - 0xAF
+          instructions[0xA0] = And.new(cpu:, source: :b)
+          instructions[0xA1] = And.new(cpu:, source: :c)
+          instructions[0xA2] = And.new(cpu:, source: :d)
+          instructions[0xA3] = And.new(cpu:, source: :e)
+          instructions[0xA4] = And.new(cpu:, source: :h)
+          instructions[0xA5] = And.new(cpu:, source: :l)
+          instructions[0xA6] = And.new(cpu:, source: :mem_hl)
+          instructions[0xA7] = And.new(cpu:, source: :a)
+          instructions[0xA8] = Xor.new(cpu:, source: :b)
+          instructions[0xA9] = Xor.new(cpu:, source: :c)
+          instructions[0xAA] = Xor.new(cpu:, source: :d)
+          instructions[0xAB] = Xor.new(cpu:, source: :e)
+          instructions[0xAC] = Xor.new(cpu:, source: :h)
+          instructions[0xAD] = Xor.new(cpu:, source: :l)
+          instructions[0xAE] = Xor.new(cpu:, source: :mem_hl)
+          instructions[0xAF] = Xor.new(cpu:, source: :a)
+
+          # Opcodes 0xB0 - 0xBF
+          instructions[0xB0] = Or.new(cpu:, source: :b)
+          instructions[0xB1] = Or.new(cpu:, source: :c)
+          instructions[0xB2] = Or.new(cpu:, source: :d)
+          instructions[0xB3] = Or.new(cpu:, source: :e)
+          instructions[0xB4] = Or.new(cpu:, source: :h)
+          instructions[0xB5] = Or.new(cpu:, source: :l)
+          instructions[0xB6] = Or.new(cpu:, source: :mem_hl)
+          instructions[0xB7] = Or.new(cpu:, source: :a)
+          instructions[0xB8] = Cp.new(cpu:, source: :b)
+          instructions[0xB9] = Cp.new(cpu:, source: :c)
+          instructions[0xBA] = Cp.new(cpu:, source: :d)
+          instructions[0xBB] = Cp.new(cpu:, source: :e)
+          instructions[0xBC] = Cp.new(cpu:, source: :h)
+          instructions[0xBD] = Cp.new(cpu:, source: :l)
+          instructions[0xBE] = Cp.new(cpu:, source: :mem_hl)
+          instructions[0xBF] = Cp.new(cpu:, source: :a)
+
+          # Opcodes 0xC0 - 0xCF
+          instructions[0xC0] = Ret.new(cpu:, condition: :nz)
+          instructions[0xC1] = Pop.new(cpu:, reg16: :bc)
+          instructions[0xC2] = Jp.new(cpu:, location: :imm16, condition: :nz)
+          instructions[0xC3] = Jp.new(cpu:, location: :imm16)
+          instructions[0xC4] = Call.new(cpu:, condition: :nz)
+          instructions[0xC5] = Push.new(cpu:, reg16: :bc)
+          instructions[0xC6] = Add8.new(cpu:, source: :imm8)
+          instructions[0xC7] = Rst.new(cpu:, vector: 0x00)
+          instructions[0xC8] = Ret.new(cpu:, condition: :z)
+          instructions[0xC9] = Ret.new(cpu:)
+          instructions[0xCA] = Jp.new(cpu:, location: :imm16, condition: :z)
+          # instructions[0xCB] => Handled in the cpu decode_instruction.
+          instructions[0xCC] = Call.new(cpu:, condition: :z)
+          instructions[0xCD] = Call.new(cpu:)
+          instructions[0xCE] = Adc.new(cpu:, source: :imm8)
+          instructions[0xCF] = Rst.new(cpu:, vector: 0x08)
+
+          # Opcodes 0xD0 - 0xDF
+          instructions[0xD0] = Ret.new(cpu:, condition: :nc)
+          instructions[0xD1] = Pop.new(cpu:, reg16: :de)
+          instructions[0xD2] = Jp.new(cpu:, location: :imm16, condition: :nc)
+          instructions[0xD3] = nil # not implemented in the Game Boy
+          instructions[0xD4] = Call.new(cpu:, condition: :nc)
+          instructions[0xD5] = Push.new(cpu:, reg16: :de)
+          instructions[0xD6] = Sub.new(cpu:, source: :imm8)
+          instructions[0xD7] = Rst.new(cpu:, vector: 0x10)
+          instructions[0xD8] = Ret.new(cpu:, condition: :c)
+          instructions[0xD9] = Ret.new(cpu:, enable_ime: true)
+          instructions[0xDA] = Jp.new(cpu:, location: :imm16, condition: :c)
+          instructions[0xDB] = nil # not implemented in the Game Boy
+          instructions[0xDC] = Call.new(cpu:, condition: :c)
+          instructions[0xDD] = nil # not implemented in the Game Boy
+          instructions[0xDE] = Sbc.new(cpu:, source: :imm8)
+          instructions[0xDF] = Rst.new(cpu:, vector: 0x18)
+
+          # Opcodes 0xE0 - 0xEF
+          instructions[0xE0] = Ldh.new(cpu:, target: :mem_unsig8, source: :a)
+          instructions[0xE1] = Pop.new(cpu:, reg16: :hl)
+          instructions[0xE2] = Ldh.new(cpu:, target: :mem_c, source: :a)
+          instructions[0xE3] = nil # not implemented in the Game Boy
+          instructions[0xE4] = nil # not implemented in the Game Boy
+          instructions[0xE5] = Push.new(cpu:, reg16: :hl)
+          instructions[0xE6] = And.new(cpu:, source: :imm8)
+          instructions[0xE7] = Rst.new(cpu:, vector: 0x20)
+          instructions[0xE8] = Add16.new(cpu:, target: :sp, source: :sig8)
+          instructions[0xE9] = Jp.new(cpu:, location: :hl)
+          instructions[0xEA] = Ld8.new(cpu:, target: :mem_imm16, source: :a)
+          instructions[0xEB] = nil # not implemented in the Game Boy
+          instructions[0xEC] = nil # not implemented in the Game Boy
+          instructions[0xED] = nil # not implemented in the Game Boy
+          instructions[0xEE] = Xor.new(cpu:, source: :imm8)
+          instructions[0xEF] = Rst.new(cpu:, vector: 0x28)
+
+          # Opcodes 0xF0 - 0xFF
+          instructions[0xF0] = Ldh.new(cpu:, target: :a, source: :mem_unsig8)
+          instructions[0xF1] = Pop.new(cpu:, reg16: :af)
+          instructions[0xF2] = Ldh.new(cpu:, target: :a, source: :mem_c)
+          instructions[0xF3] = Di.new(cpu:)
+          instructions[0xF4] = nil # not implemented in the Game Boy
+          instructions[0xF5] = Push.new(cpu:, reg16: :af)
+          instructions[0xF6] = Or.new(cpu:, source: :imm8)
+          instructions[0xF7] = Rst.new(cpu:, vector: 0x30)
+          instructions[0xF8] = Ld16.new(cpu:, target: :hl, source: :sp_plus_sig8)
+          instructions[0xF9] = Ld16.new(cpu:, target: :sp, source: :hl)
+          instructions[0xFA] = Ld8.new(cpu:, target: :a, source: :mem_imm16)
+          instructions[0xFB] = Ei.new(cpu:)
+          instructions[0xFC] = nil # not implemented in the Game Boy
+          instructions[0xFD] = nil # not implemented in the Game Boy
+          instructions[0xFE] = Cp.new(cpu:, source: :imm8)
+          instructions[0xFF] = Rst.new(cpu:, vector: 0x38)
+
+          instructions.freeze
+        end
+
+        def self.load_cb_instructions(cpu:)
+          cb_instructions = Array.new(256)
+
+          # Opcodes 0x00 -> 0x0F
+          cb_instructions[0x00] = CbRlc.new(cpu:, target: :b)
+          cb_instructions[0x01] = CbRlc.new(cpu:, target: :c)
+          cb_instructions[0x02] = CbRlc.new(cpu:, target: :d)
+          cb_instructions[0x03] = CbRlc.new(cpu:, target: :e)
+          cb_instructions[0x04] = CbRlc.new(cpu:, target: :h)
+          cb_instructions[0x05] = CbRlc.new(cpu:, target: :l)
+          cb_instructions[0x06] = CbRlc.new(cpu:, target: :mem_hl)
+          cb_instructions[0x07] = CbRlc.new(cpu:, target: :a)
+          cb_instructions[0x08] = CbRrc.new(cpu:, target: :b)
+          cb_instructions[0x09] = CbRrc.new(cpu:, target: :c)
+          cb_instructions[0x0A] = CbRrc.new(cpu:, target: :d)
+          cb_instructions[0x0B] = CbRrc.new(cpu:, target: :e)
+          cb_instructions[0x0C] = CbRrc.new(cpu:, target: :h)
+          cb_instructions[0x0D] = CbRrc.new(cpu:, target: :l)
+          cb_instructions[0x0E] = CbRrc.new(cpu:, target: :mem_hl)
+          cb_instructions[0x0F] = CbRrc.new(cpu:, target: :a)
+
+          # Opcodes 0x10 -> 0x1F
+          cb_instructions[0x10] = CbRl.new(cpu:, target: :b)
+          cb_instructions[0x11] = CbRl.new(cpu:, target: :c)
+          cb_instructions[0x12] = CbRl.new(cpu:, target: :d)
+          cb_instructions[0x13] = CbRl.new(cpu:, target: :e)
+          cb_instructions[0x14] = CbRl.new(cpu:, target: :h)
+          cb_instructions[0x15] = CbRl.new(cpu:, target: :l)
+          cb_instructions[0x16] = CbRl.new(cpu:, target: :mem_hl)
+          cb_instructions[0x17] = CbRl.new(cpu:, target: :a)
+          cb_instructions[0x18] = CbRr.new(cpu:, target: :b)
+          cb_instructions[0x19] = CbRr.new(cpu:, target: :c)
+          cb_instructions[0x1A] = CbRr.new(cpu:, target: :d)
+          cb_instructions[0x1B] = CbRr.new(cpu:, target: :e)
+          cb_instructions[0x1C] = CbRr.new(cpu:, target: :h)
+          cb_instructions[0x1D] = CbRr.new(cpu:, target: :l)
+          cb_instructions[0x1E] = CbRr.new(cpu:, target: :mem_hl)
+          cb_instructions[0x1F] = CbRr.new(cpu:, target: :a)
+
+          # Opcodes 0x20 -> 0x2F
+          cb_instructions[0x20] = CbSla.new(cpu:, target: :b)
+          cb_instructions[0x21] = CbSla.new(cpu:, target: :c)
+          cb_instructions[0x22] = CbSla.new(cpu:, target: :d)
+          cb_instructions[0x23] = CbSla.new(cpu:, target: :e)
+          cb_instructions[0x24] = CbSla.new(cpu:, target: :h)
+          cb_instructions[0x25] = CbSla.new(cpu:, target: :l)
+          cb_instructions[0x26] = CbSla.new(cpu:, target: :mem_hl)
+          cb_instructions[0x27] = CbSla.new(cpu:, target: :a)
+          cb_instructions[0x28] = CbSra.new(cpu:, target: :b)
+          cb_instructions[0x29] = CbSra.new(cpu:, target: :c)
+          cb_instructions[0x2A] = CbSra.new(cpu:, target: :d)
+          cb_instructions[0x2B] = CbSra.new(cpu:, target: :e)
+          cb_instructions[0x2C] = CbSra.new(cpu:, target: :h)
+          cb_instructions[0x2D] = CbSra.new(cpu:, target: :l)
+          cb_instructions[0x2E] = CbSra.new(cpu:, target: :mem_hl)
+          cb_instructions[0x2F] = CbSra.new(cpu:, target: :a)
+
+          # Opcodes 0x30 -> 0x3F
+          cb_instructions[0x30] = CbSwap.new(cpu:, target: :b)
+          cb_instructions[0x31] = CbSwap.new(cpu:, target: :c)
+          cb_instructions[0x32] = CbSwap.new(cpu:, target: :d)
+          cb_instructions[0x33] = CbSwap.new(cpu:, target: :e)
+          cb_instructions[0x34] = CbSwap.new(cpu:, target: :h)
+          cb_instructions[0x35] = CbSwap.new(cpu:, target: :l)
+          cb_instructions[0x36] = CbSwap.new(cpu:, target: :mem_hl)
+          cb_instructions[0x37] = CbSwap.new(cpu:, target: :a)
+          cb_instructions[0x38] = CbSrl.new(cpu:, target: :b)
+          cb_instructions[0x39] = CbSrl.new(cpu:, target: :c)
+          cb_instructions[0x3A] = CbSrl.new(cpu:, target: :d)
+          cb_instructions[0x3B] = CbSrl.new(cpu:, target: :e)
+          cb_instructions[0x3C] = CbSrl.new(cpu:, target: :h)
+          cb_instructions[0x3D] = CbSrl.new(cpu:, target: :l)
+          cb_instructions[0x3E] = CbSrl.new(cpu:, target: :mem_hl)
+          cb_instructions[0x3F] = CbSrl.new(cpu:, target: :a)
+
+          # Opcodes 0x40 -> 0x4F
+          cb_instructions[0x40] = CbBit.new(cpu:, bit_pos: 0, target: :b)
+          cb_instructions[0x41] = CbBit.new(cpu:, bit_pos: 0, target: :c)
+          cb_instructions[0x42] = CbBit.new(cpu:, bit_pos: 0, target: :d)
+          cb_instructions[0x43] = CbBit.new(cpu:, bit_pos: 0, target: :e)
+          cb_instructions[0x44] = CbBit.new(cpu:, bit_pos: 0, target: :h)
+          cb_instructions[0x45] = CbBit.new(cpu:, bit_pos: 0, target: :l)
+          cb_instructions[0x46] = CbBit.new(cpu:, bit_pos: 0, target: :mem_hl)
+          cb_instructions[0x47] = CbBit.new(cpu:, bit_pos: 0, target: :a)
+          cb_instructions[0x48] = CbBit.new(cpu:, bit_pos: 1, target: :b)
+          cb_instructions[0x49] = CbBit.new(cpu:, bit_pos: 1, target: :c)
+          cb_instructions[0x4A] = CbBit.new(cpu:, bit_pos: 1, target: :d)
+          cb_instructions[0x4B] = CbBit.new(cpu:, bit_pos: 1, target: :e)
+          cb_instructions[0x4C] = CbBit.new(cpu:, bit_pos: 1, target: :h)
+          cb_instructions[0x4D] = CbBit.new(cpu:, bit_pos: 1, target: :l)
+          cb_instructions[0x4E] = CbBit.new(cpu:, bit_pos: 1, target: :mem_hl)
+          cb_instructions[0x4F] = CbBit.new(cpu:, bit_pos: 1, target: :a)
+
+          # Opcodes 0x50 -> 0x5F
+          cb_instructions[0x50] = CbBit.new(cpu:, bit_pos: 2, target: :b)
+          cb_instructions[0x51] = CbBit.new(cpu:, bit_pos: 2, target: :c)
+          cb_instructions[0x52] = CbBit.new(cpu:, bit_pos: 2, target: :d)
+          cb_instructions[0x53] = CbBit.new(cpu:, bit_pos: 2, target: :e)
+          cb_instructions[0x54] = CbBit.new(cpu:, bit_pos: 2, target: :h)
+          cb_instructions[0x55] = CbBit.new(cpu:, bit_pos: 2, target: :l)
+          cb_instructions[0x56] = CbBit.new(cpu:, bit_pos: 2, target: :mem_hl)
+          cb_instructions[0x57] = CbBit.new(cpu:, bit_pos: 2, target: :a)
+          cb_instructions[0x58] = CbBit.new(cpu:, bit_pos: 3, target: :b)
+          cb_instructions[0x59] = CbBit.new(cpu:, bit_pos: 3, target: :c)
+          cb_instructions[0x5A] = CbBit.new(cpu:, bit_pos: 3, target: :d)
+          cb_instructions[0x5B] = CbBit.new(cpu:, bit_pos: 3, target: :e)
+          cb_instructions[0x5C] = CbBit.new(cpu:, bit_pos: 3, target: :h)
+          cb_instructions[0x5D] = CbBit.new(cpu:, bit_pos: 3, target: :l)
+          cb_instructions[0x5E] = CbBit.new(cpu:, bit_pos: 3, target: :mem_hl)
+          cb_instructions[0x5F] = CbBit.new(cpu:, bit_pos: 3, target: :a)
+
+          # Opcodes 0x60 -> 0x6F
+          cb_instructions[0x60] = CbBit.new(cpu:, bit_pos: 4, target: :b)
+          cb_instructions[0x61] = CbBit.new(cpu:, bit_pos: 4, target: :c)
+          cb_instructions[0x62] = CbBit.new(cpu:, bit_pos: 4, target: :d)
+          cb_instructions[0x63] = CbBit.new(cpu:, bit_pos: 4, target: :e)
+          cb_instructions[0x64] = CbBit.new(cpu:, bit_pos: 4, target: :h)
+          cb_instructions[0x65] = CbBit.new(cpu:, bit_pos: 4, target: :l)
+          cb_instructions[0x66] = CbBit.new(cpu:, bit_pos: 4, target: :mem_hl)
+          cb_instructions[0x67] = CbBit.new(cpu:, bit_pos: 4, target: :a)
+          cb_instructions[0x68] = CbBit.new(cpu:, bit_pos: 5, target: :b)
+          cb_instructions[0x69] = CbBit.new(cpu:, bit_pos: 5, target: :c)
+          cb_instructions[0x6A] = CbBit.new(cpu:, bit_pos: 5, target: :d)
+          cb_instructions[0x6B] = CbBit.new(cpu:, bit_pos: 5, target: :e)
+          cb_instructions[0x6C] = CbBit.new(cpu:, bit_pos: 5, target: :h)
+          cb_instructions[0x6D] = CbBit.new(cpu:, bit_pos: 5, target: :l)
+          cb_instructions[0x6E] = CbBit.new(cpu:, bit_pos: 5, target: :mem_hl)
+          cb_instructions[0x6F] = CbBit.new(cpu:, bit_pos: 5, target: :a)
+
+          # Opcodes 0x70 -> 0x7F
+          cb_instructions[0x70] = CbBit.new(cpu:, bit_pos: 6, target: :b)
+          cb_instructions[0x71] = CbBit.new(cpu:, bit_pos: 6, target: :c)
+          cb_instructions[0x72] = CbBit.new(cpu:, bit_pos: 6, target: :d)
+          cb_instructions[0x73] = CbBit.new(cpu:, bit_pos: 6, target: :e)
+          cb_instructions[0x74] = CbBit.new(cpu:, bit_pos: 6, target: :h)
+          cb_instructions[0x75] = CbBit.new(cpu:, bit_pos: 6, target: :l)
+          cb_instructions[0x76] = CbBit.new(cpu:, bit_pos: 6, target: :mem_hl)
+          cb_instructions[0x77] = CbBit.new(cpu:, bit_pos: 6, target: :a)
+          cb_instructions[0x78] = CbBit.new(cpu:, bit_pos: 7, target: :b)
+          cb_instructions[0x79] = CbBit.new(cpu:, bit_pos: 7, target: :c)
+          cb_instructions[0x7A] = CbBit.new(cpu:, bit_pos: 7, target: :d)
+          cb_instructions[0x7B] = CbBit.new(cpu:, bit_pos: 7, target: :e)
+          cb_instructions[0x7C] = CbBit.new(cpu:, bit_pos: 7, target: :h)
+          cb_instructions[0x7D] = CbBit.new(cpu:, bit_pos: 7, target: :l)
+          cb_instructions[0x7E] = CbBit.new(cpu:, bit_pos: 7, target: :mem_hl)
+          cb_instructions[0x7F] = CbBit.new(cpu:, bit_pos: 7, target: :a)
+
+          # Opcodes 0x80 -> 0x8F
+          cb_instructions[0x80] = CbRes.new(cpu:, bit_pos: 0, target: :b)
+          cb_instructions[0x81] = CbRes.new(cpu:, bit_pos: 0, target: :c)
+          cb_instructions[0x82] = CbRes.new(cpu:, bit_pos: 0, target: :d)
+          cb_instructions[0x83] = CbRes.new(cpu:, bit_pos: 0, target: :e)
+          cb_instructions[0x84] = CbRes.new(cpu:, bit_pos: 0, target: :h)
+          cb_instructions[0x85] = CbRes.new(cpu:, bit_pos: 0, target: :l)
+          cb_instructions[0x86] = CbRes.new(cpu:, bit_pos: 0, target: :mem_hl)
+          cb_instructions[0x87] = CbRes.new(cpu:, bit_pos: 0, target: :a)
+          cb_instructions[0x88] = CbRes.new(cpu:, bit_pos: 1, target: :b)
+          cb_instructions[0x89] = CbRes.new(cpu:, bit_pos: 1, target: :c)
+          cb_instructions[0x8A] = CbRes.new(cpu:, bit_pos: 1, target: :d)
+          cb_instructions[0x8B] = CbRes.new(cpu:, bit_pos: 1, target: :e)
+          cb_instructions[0x8C] = CbRes.new(cpu:, bit_pos: 1, target: :h)
+          cb_instructions[0x8D] = CbRes.new(cpu:, bit_pos: 1, target: :l)
+          cb_instructions[0x8E] = CbRes.new(cpu:, bit_pos: 1, target: :mem_hl)
+          cb_instructions[0x8F] = CbRes.new(cpu:, bit_pos: 1, target: :a)
+
+          # Opcodes 0x90 -> 0x9F
+          cb_instructions[0x90] = CbRes.new(cpu:, bit_pos: 2, target: :b)
+          cb_instructions[0x91] = CbRes.new(cpu:, bit_pos: 2, target: :c)
+          cb_instructions[0x92] = CbRes.new(cpu:, bit_pos: 2, target: :d)
+          cb_instructions[0x93] = CbRes.new(cpu:, bit_pos: 2, target: :e)
+          cb_instructions[0x94] = CbRes.new(cpu:, bit_pos: 2, target: :h)
+          cb_instructions[0x95] = CbRes.new(cpu:, bit_pos: 2, target: :l)
+          cb_instructions[0x96] = CbRes.new(cpu:, bit_pos: 2, target: :mem_hl)
+          cb_instructions[0x97] = CbRes.new(cpu:, bit_pos: 2, target: :a)
+          cb_instructions[0x98] = CbRes.new(cpu:, bit_pos: 3, target: :b)
+          cb_instructions[0x99] = CbRes.new(cpu:, bit_pos: 3, target: :c)
+          cb_instructions[0x9A] = CbRes.new(cpu:, bit_pos: 3, target: :d)
+          cb_instructions[0x9B] = CbRes.new(cpu:, bit_pos: 3, target: :e)
+          cb_instructions[0x9C] = CbRes.new(cpu:, bit_pos: 3, target: :h)
+          cb_instructions[0x9D] = CbRes.new(cpu:, bit_pos: 3, target: :l)
+          cb_instructions[0x9E] = CbRes.new(cpu:, bit_pos: 3, target: :mem_hl)
+          cb_instructions[0x9F] = CbRes.new(cpu:, bit_pos: 3, target: :a)
+
+          # Opcodes 0xA0 -> 0xAF
+          cb_instructions[0xA0] = CbRes.new(cpu:, bit_pos: 4, target: :b)
+          cb_instructions[0xA1] = CbRes.new(cpu:, bit_pos: 4, target: :c)
+          cb_instructions[0xA2] = CbRes.new(cpu:, bit_pos: 4, target: :d)
+          cb_instructions[0xA3] = CbRes.new(cpu:, bit_pos: 4, target: :e)
+          cb_instructions[0xA4] = CbRes.new(cpu:, bit_pos: 4, target: :h)
+          cb_instructions[0xA5] = CbRes.new(cpu:, bit_pos: 4, target: :l)
+          cb_instructions[0xA6] = CbRes.new(cpu:, bit_pos: 4, target: :mem_hl)
+          cb_instructions[0xA7] = CbRes.new(cpu:, bit_pos: 4, target: :a)
+          cb_instructions[0xA8] = CbRes.new(cpu:, bit_pos: 5, target: :b)
+          cb_instructions[0xA9] = CbRes.new(cpu:, bit_pos: 5, target: :c)
+          cb_instructions[0xAA] = CbRes.new(cpu:, bit_pos: 5, target: :d)
+          cb_instructions[0xAB] = CbRes.new(cpu:, bit_pos: 5, target: :e)
+          cb_instructions[0xAC] = CbRes.new(cpu:, bit_pos: 5, target: :h)
+          cb_instructions[0xAD] = CbRes.new(cpu:, bit_pos: 5, target: :l)
+          cb_instructions[0xAE] = CbRes.new(cpu:, bit_pos: 5, target: :mem_hl)
+          cb_instructions[0xAF] = CbRes.new(cpu:, bit_pos: 5, target: :a)
+
+          # Opcodes 0xB0 -> 0xBF
+          cb_instructions[0xB0] = CbRes.new(cpu:, bit_pos: 6, target: :b)
+          cb_instructions[0xB1] = CbRes.new(cpu:, bit_pos: 6, target: :c)
+          cb_instructions[0xB2] = CbRes.new(cpu:, bit_pos: 6, target: :d)
+          cb_instructions[0xB3] = CbRes.new(cpu:, bit_pos: 6, target: :e)
+          cb_instructions[0xB4] = CbRes.new(cpu:, bit_pos: 6, target: :h)
+          cb_instructions[0xB5] = CbRes.new(cpu:, bit_pos: 6, target: :l)
+          cb_instructions[0xB6] = CbRes.new(cpu:, bit_pos: 6, target: :mem_hl)
+          cb_instructions[0xB7] = CbRes.new(cpu:, bit_pos: 6, target: :a)
+          cb_instructions[0xB8] = CbRes.new(cpu:, bit_pos: 7, target: :b)
+          cb_instructions[0xB9] = CbRes.new(cpu:, bit_pos: 7, target: :c)
+          cb_instructions[0xBA] = CbRes.new(cpu:, bit_pos: 7, target: :d)
+          cb_instructions[0xBB] = CbRes.new(cpu:, bit_pos: 7, target: :e)
+          cb_instructions[0xBC] = CbRes.new(cpu:, bit_pos: 7, target: :h)
+          cb_instructions[0xBD] = CbRes.new(cpu:, bit_pos: 7, target: :l)
+          cb_instructions[0xBE] = CbRes.new(cpu:, bit_pos: 7, target: :mem_hl)
+          cb_instructions[0xBF] = CbRes.new(cpu:, bit_pos: 7, target: :a)
+
+          # Opcodes 0xC0 -> 0xCF
+          cb_instructions[0xC0] = CbSet.new(cpu:, bit_pos: 0, target: :b)
+          cb_instructions[0xC1] = CbSet.new(cpu:, bit_pos: 0, target: :c)
+          cb_instructions[0xC2] = CbSet.new(cpu:, bit_pos: 0, target: :d)
+          cb_instructions[0xC3] = CbSet.new(cpu:, bit_pos: 0, target: :e)
+          cb_instructions[0xC4] = CbSet.new(cpu:, bit_pos: 0, target: :h)
+          cb_instructions[0xC5] = CbSet.new(cpu:, bit_pos: 0, target: :l)
+          cb_instructions[0xC6] = CbSet.new(cpu:, bit_pos: 0, target: :mem_hl)
+          cb_instructions[0xC7] = CbSet.new(cpu:, bit_pos: 0, target: :a)
+          cb_instructions[0xC8] = CbSet.new(cpu:, bit_pos: 1, target: :b)
+          cb_instructions[0xC9] = CbSet.new(cpu:, bit_pos: 1, target: :c)
+          cb_instructions[0xCA] = CbSet.new(cpu:, bit_pos: 1, target: :d)
+          cb_instructions[0xCB] = CbSet.new(cpu:, bit_pos: 1, target: :e)
+          cb_instructions[0xCC] = CbSet.new(cpu:, bit_pos: 1, target: :h)
+          cb_instructions[0xCD] = CbSet.new(cpu:, bit_pos: 1, target: :l)
+          cb_instructions[0xCE] = CbSet.new(cpu:, bit_pos: 1, target: :mem_hl)
+          cb_instructions[0xCF] = CbSet.new(cpu:, bit_pos: 1, target: :a)
+
+          # Opcodes 0xD0 -> 0xDF
+          cb_instructions[0xD0] = CbSet.new(cpu:, bit_pos: 2, target: :b)
+          cb_instructions[0xD1] = CbSet.new(cpu:, bit_pos: 2, target: :c)
+          cb_instructions[0xD2] = CbSet.new(cpu:, bit_pos: 2, target: :d)
+          cb_instructions[0xD3] = CbSet.new(cpu:, bit_pos: 2, target: :e)
+          cb_instructions[0xD4] = CbSet.new(cpu:, bit_pos: 2, target: :h)
+          cb_instructions[0xD5] = CbSet.new(cpu:, bit_pos: 2, target: :l)
+          cb_instructions[0xD6] = CbSet.new(cpu:, bit_pos: 2, target: :mem_hl)
+          cb_instructions[0xD7] = CbSet.new(cpu:, bit_pos: 2, target: :a)
+          cb_instructions[0xD8] = CbSet.new(cpu:, bit_pos: 3, target: :b)
+          cb_instructions[0xD9] = CbSet.new(cpu:, bit_pos: 3, target: :c)
+          cb_instructions[0xDA] = CbSet.new(cpu:, bit_pos: 3, target: :d)
+          cb_instructions[0xDB] = CbSet.new(cpu:, bit_pos: 3, target: :e)
+          cb_instructions[0xDC] = CbSet.new(cpu:, bit_pos: 3, target: :h)
+          cb_instructions[0xDD] = CbSet.new(cpu:, bit_pos: 3, target: :l)
+          cb_instructions[0xDE] = CbSet.new(cpu:, bit_pos: 3, target: :mem_hl)
+          cb_instructions[0xDF] = CbSet.new(cpu:, bit_pos: 3, target: :a)
+
+          # Opcodes 0xE0 -> 0xEF
+          cb_instructions[0xE0] = CbSet.new(cpu:, bit_pos: 4, target: :b)
+          cb_instructions[0xE1] = CbSet.new(cpu:, bit_pos: 4, target: :c)
+          cb_instructions[0xE2] = CbSet.new(cpu:, bit_pos: 4, target: :d)
+          cb_instructions[0xE3] = CbSet.new(cpu:, bit_pos: 4, target: :e)
+          cb_instructions[0xE4] = CbSet.new(cpu:, bit_pos: 4, target: :h)
+          cb_instructions[0xE5] = CbSet.new(cpu:, bit_pos: 4, target: :l)
+          cb_instructions[0xE6] = CbSet.new(cpu:, bit_pos: 4, target: :mem_hl)
+          cb_instructions[0xE7] = CbSet.new(cpu:, bit_pos: 4, target: :a)
+          cb_instructions[0xE8] = CbSet.new(cpu:, bit_pos: 5, target: :b)
+          cb_instructions[0xE9] = CbSet.new(cpu:, bit_pos: 5, target: :c)
+          cb_instructions[0xEA] = CbSet.new(cpu:, bit_pos: 5, target: :d)
+          cb_instructions[0xEB] = CbSet.new(cpu:, bit_pos: 5, target: :e)
+          cb_instructions[0xEC] = CbSet.new(cpu:, bit_pos: 5, target: :h)
+          cb_instructions[0xED] = CbSet.new(cpu:, bit_pos: 5, target: :l)
+          cb_instructions[0xEE] = CbSet.new(cpu:, bit_pos: 5, target: :mem_hl)
+          cb_instructions[0xEF] = CbSet.new(cpu:, bit_pos: 5, target: :a)
+
+          # Opcodes 0xF0 -> 0xFF
+          cb_instructions[0xF0] = CbSet.new(cpu:, bit_pos: 6, target: :b)
+          cb_instructions[0xF1] = CbSet.new(cpu:, bit_pos: 6, target: :c)
+          cb_instructions[0xF2] = CbSet.new(cpu:, bit_pos: 6, target: :d)
+          cb_instructions[0xF3] = CbSet.new(cpu:, bit_pos: 6, target: :e)
+          cb_instructions[0xF4] = CbSet.new(cpu:, bit_pos: 6, target: :h)
+          cb_instructions[0xF5] = CbSet.new(cpu:, bit_pos: 6, target: :l)
+          cb_instructions[0xF6] = CbSet.new(cpu:, bit_pos: 6, target: :mem_hl)
+          cb_instructions[0xF7] = CbSet.new(cpu:, bit_pos: 6, target: :a)
+          cb_instructions[0xF8] = CbSet.new(cpu:, bit_pos: 7, target: :b)
+          cb_instructions[0xF9] = CbSet.new(cpu:, bit_pos: 7, target: :c)
+          cb_instructions[0xFA] = CbSet.new(cpu:, bit_pos: 7, target: :d)
+          cb_instructions[0xFB] = CbSet.new(cpu:, bit_pos: 7, target: :e)
+          cb_instructions[0xFC] = CbSet.new(cpu:, bit_pos: 7, target: :h)
+          cb_instructions[0xFD] = CbSet.new(cpu:, bit_pos: 7, target: :l)
+          cb_instructions[0xFE] = CbSet.new(cpu:, bit_pos: 7, target: :mem_hl)
+          cb_instructions[0xFF] = CbSet.new(cpu:, bit_pos: 7, target: :a)
+
+          cb_instructions.freeze
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/MethodLength, Metrics/ModuleLength