badline 0.6.0 → 0.6.1

data/lib/badline/cpu/core.rb

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require "badline/cpu/microcode"
+require "badline/cpu/addressing"
+require "badline/cpu/operations"
+require "badline/cpu/stack_operations"
+require "badline/cpu/boundary"
+require "badline/cpu/saved_state"
+
+module Badline
+  class CPU
+    STATUS_FLAGS = [:carry, :zero, :interrupt, :decimal, :break, 1, :overflow, :negative].freeze
+
+    # The 6502 core, on whatever bus +memory+ is. The C64's 6510 (CPU) and
+    # the 1541's 6502 (Drive1541::CPU) each include it.
+    module Core
+      include IntegerHelper
+      include InstructionSet
+      include Interrupts
+      include Traps
+      include Addressing
+      include Operations
+      include StackOperations
+      include Boundary
+      include SavedState
+
+      attr_reader :memory, :instructions, :boundary_crossed, :cycles, :pending_write
+      attr_accessor :program_counter, :stack_pointer, :status, :a, :x, :y, :nmi, :irq
+
+      alias pending_write? pending_write
+
+      # +ane_constant+ is ANE's magic constant, which varies from chip to
+      # chip. The default is the C64 6510's.
+      def initialize(memory, debug: false, ane_constant: 0xef)
+        @debug = debug
+        @ane_constant = ane_constant
+        @memory = memory
+        @status = CPUStatus.new(STATUS_FLAGS, value: 0b00100000)
+        reset_registers
+
+        @nmi = @irq = false
+        @irq_sample = @irq_pending = false
+        @nmi_sample = @nmi_pending = false
+        @skip_poll = false
+        @boundary_crossed = false
+        @interrupt = nil
+        @brk = false
+        @pending_write = false
+        @stalled_at = nil
+        @so_high = true
+
+        @cycles = 0
+        @instructions = 0
+        @traps = nil
+        end_sequence
+      end
+
+      def reset!
+        status.interrupt = true
+        reset_registers
+        @nmi = false
+        @irq_sample = @irq_pending = false
+        @nmi_sample = @nmi_pending = false
+        @skip_poll = false
+        @pending_write = false
+        end_sequence
+      end
+
+      def p
+        status.value
+      end
+
+      def p=(new_value)
+        status.value = new_value
+      end
+
+      def cycle!
+        poll # the interrupt lines
+
+        # Run the next step
+        index = @index
+        @index = index + 1
+        send(@plan[index])
+        @cycles += 1
+
+        # Record if the next step writes to memory
+        @pending_write = @writes[@index]
+        nil
+      end
+
+      # Called instead of #cycle! on a cycle the VIC holds the CPU through
+      # BA. Records which cycle the CPU was stalled before, and keeps
+      # sampling the interrupt lines.
+      def stall!
+        @stalled_at = @cycles
+        sample_while_stalled
+      end
+
+      # The 6502's SO (set overflow) pin, which the 6510 leaves out, so the
+      # C64 never drives it. A falling edge sets V and a held level does
+      # nothing more.
+      def so=(high)
+        @status.overflow = true if @so_high && !high
+        @so_high = high
+      end
+
+      # Pulses SO: pulls it low, which sets V, and releases it.
+      def so!
+        @status.overflow = true
+        @so_high = true
+      end
+
+      def jammed?
+        @plan.equal?(JAMMED_PLAN)
+      end
+
+      # Runs to the end of the instruction, or until the CPU jams.
+      def step!
+        cycle!
+        cycle! until @plan.equal?(FETCH_PLAN) || jammed?
+        nil
+      end
+
+      # Whether the next cycle fetches an opcode.
+      def boundary? = @index.zero? && @plan.equal?(FETCH_PLAN)
+
+      def trapped? = !@traps.nil?
+
+      def inspect
+        "Cycles: #{@cycles}, PC: #{format16(program_counter)}, " \
+          "SP: #{format8(stack_pointer)}, A: #{format8(a)}, X: #{format8(x)}, " \
+          "Y: #{format8(y)}, P: #{format8(p)}"
+      end
+
+      private
+
+      # True when the CPU was stalled right before this cycle.
+      def stalled_before_this_cycle?
+        @stalled_at == @cycles
+      end
+
+      # True when the CPU was stalled right before the cycle that preceded
+      # this one.
+      def stalled_before_previous_cycle?
+        @stalled_at == @cycles - 1
+      end
+
+      def write_byte(addr, value)
+        @memory.poke(addr, value)
+      end
+
+      def stack_address(offset = 0)
+        0x0100 | ((@stack_pointer + offset) & 0xff)
+      end
+
+      def reset_registers
+        # The program counter is initialized from the reset vector
+        @program_counter = @memory.peek16(0xfffc)
+        # Stack pointer starts at 0x01ff and grows down
+        @stack_pointer = 0xff
+        @a = @x = @y = 0x0
+      end
+    end
+  end
+end

data/lib/badline/cpu.rb

@@ -1,221 +1,10 @@
 # frozen_string_literal: true
 
-require "badline/cpu/microcode"
-require "badline/cpu/addressing"
-require "badline/cpu/operations"
-require "badline/cpu/stack_operations"
-require "badline/cpu/saved_state"
+require "badline/cpu/core"
 
 module Badline
+  # The C64's 6510, on the AddressBus.
   class CPU
-    STATUS_FLAGS = [:carry, :zero, :interrupt, :decimal, :break, 1, :overflow, :negative].freeze
-
-    include IntegerHelper
-    include InstructionSet
-    include Interrupts
-    include Traps
-    include Addressing
-    include Operations
-    include StackOperations
-    include SavedState
-
-    attr_reader :memory, :instructions, :boundary_crossed, :cycles, :pending_write
-    attr_accessor :program_counter, :stack_pointer, :status, :a, :x, :y, :nmi, :irq
-
-    alias pending_write? pending_write
-
-    # +ane_constant+ is ANE's magic constant, which varies from chip to
-    # chip. The default is the C64 6510's.
-    def initialize(memory, debug: false, ane_constant: 0xef)
-      @debug = debug
-      @ane_constant = ane_constant
-      @memory = memory
-      @status = CPUStatus.new(STATUS_FLAGS, value: 0b00100000)
-      reset_registers
-
-      @nmi = @irq = false
-      @irq_sample = @irq_pending = false
-      @nmi_sample = @nmi_pending = false
-      @skip_poll = false
-      @boundary_crossed = false
-      @interrupt = nil
-      @brk = false
-      @pending_write = false
-      @stalled_at = nil
-      @so_high = true
-
-      @cycles = 0
-      @instructions = 0
-      @traps = nil
-      end_sequence
-    end
-
-    def reset!
-      status.interrupt = true
-      reset_registers
-      @nmi = false
-      @irq_sample = @irq_pending = false
-      @nmi_sample = @nmi_pending = false
-      @skip_poll = false
-      @pending_write = false
-      end_sequence
-    end
-
-    def p
-      status.value
-    end
-
-    def p=(new_value)
-      status.value = new_value
-    end
-
-    def cycle!
-      poll # the interrupt lines
-
-      # Run the next step
-      index = @index
-      @index = index + 1
-      send(@plan[index])
-      @cycles += 1
-
-      # Record if the next step writes to memory
-      @pending_write = @writes[@index]
-      nil
-    end
-
-    # Called instead of #cycle! on a cycle the VIC holds the CPU through
-    # BA. Records which cycle the CPU was stalled before, and keeps
-    # sampling the interrupt lines.
-    def stall!
-      @stalled_at = @cycles
-      sample_while_stalled
-    end
-
-    # The 6502's SO (set overflow) pin, which the 6510 leaves out, so the
-    # C64 never drives it. A falling edge sets V and a held level does
-    # nothing more.
-    def so=(high)
-      @status.overflow = true if @so_high && !high
-      @so_high = high
-    end
-
-    # Pulses SO: pulls it low, which sets V, and releases it.
-    def so!
-      @status.overflow = true
-      @so_high = true
-    end
-
-    def jammed?
-      @plan.equal?(JAMMED_PLAN)
-    end
-
-    # Runs to the end of the instruction, or until the CPU jams.
-    def step!
-      cycle!
-      cycle! until @plan.equal?(FETCH_PLAN) || jammed?
-      nil
-    end
-
-    # Whether the next cycle fetches an opcode.
-    def boundary? = @index.zero? && @plan.equal?(FETCH_PLAN)
-
-    def trapped? = !@traps.nil?
-
-    # Everything the CPU holds but its cycle and instruction counts: the
-    # registers, the interrupt lines and pipeline, and what the last
-    # instruction left in its working registers. Drive1541::Idle compares
-    # it at two instruction boundaries.
-    def idle_state
-      [@program_counter, @stack_pointer, @a, @x, @y, @status.value,
-       @irq, @nmi, @irq_sample, @irq_pending, @nmi_sample, @nmi_pending, @skip_poll,
-       @boundary_irq, @boundary_nmi, @so_high, @interrupt, @brk, @pending_write, @stalled_at, @traps,
-       @operation, @optional_dummy, @boundary_crossed, @branch_taken,
-       @address, @pointer, @dummy_address, @value, @rmw_result]
-    end
-
-    # Counts +cycles+ cycles and +instructions+ instructions that ran
-    # without changing anything idle_state holds.
-    def fast_forward(cycles, instructions)
-      @cycles += cycles
-      @instructions += instructions
-    end
-
-    def inspect
-      "Cycles: #{@cycles}, PC: #{format16(program_counter)}, " \
-        "SP: #{format8(stack_pointer)}, A: #{format8(a)}, X: #{format8(x)}, " \
-        "Y: #{format8(y)}, P: #{format8(p)}"
-    end
-
-    private
-
-    # The first cycle of every instruction. Starts an interrupt if one was
-    # pending when the previous instruction ended. Otherwise reads the
-    # opcode and switches to its plan.
-    def op_fetch
-      return start_interrupt if @boundary_nmi || @boundary_irq
-
-      run_traps
-      opcode = @memory.peek(@program_counter)
-      log(opcode) if @debug
-      micro = MICROCODE[opcode]
-      @operation = micro.operation
-      @plan = micro.plan
-      @writes = micro.writes
-      @optional_dummy = micro.optional_dummy
-      @index = 1
-      @boundary_crossed = false
-      @program_counter = (@program_counter + 1) & 0xffff
-    end
-
-    def end_instruction
-      @instructions += 1
-      end_sequence
-    end
-
-    # Makes the next cycle an opcode fetch, and saves the pending interrupt
-    # flags for op_fetch. The next cycle polls before op_fetch runs, which
-    # updates the live flags.
-    def end_sequence
-      @plan = FETCH_PLAN
-      @writes = FETCH_WRITES
-      @index = 0
-      @boundary_irq = @irq_pending
-      @boundary_nmi = @nmi_pending
-    end
-
-    # True when the CPU was stalled right before this cycle.
-    def stalled_before_this_cycle?
-      @stalled_at == @cycles
-    end
-
-    # True when the CPU was stalled right before the cycle that preceded
-    # this one.
-    def stalled_before_previous_cycle?
-      @stalled_at == @cycles - 1
-    end
-
-    def write_byte(addr, value)
-      @memory.poke(addr, value)
-    end
-
-    def stack_address(offset = 0)
-      0x0100 | ((@stack_pointer + offset) & 0xff)
-    end
-
-    def reset_registers
-      # The program counter is initialized from the reset vector
-      @program_counter = @memory.peek16(0xfffc)
-      # Stack pointer starts at 0x01ff and grows down
-      @stack_pointer = 0xff
-      @a = @x = @y = 0x0
-    end
-
-    def log(opcode)
-      instruction = Instruction.find(opcode)
-      puts(
-        "#{@cycles}: PC: #{format16(@program_counter)} - " \
-        "#{instruction.name.upcase} #{instruction.addressing_mode}"
-      )
-    end
+    include Core
   end
 end

data/lib/badline/drive1541/cpu.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Badline
+  class Drive1541
+    # The drive's 6502, on the drive's Bus.
+    class CPU
+      include Badline::CPU::Core
+
+      # Everything the CPU holds but its cycle and instruction counts: the
+      # registers, the interrupt lines and pipeline, and what the last
+      # instruction left in its working registers. Drive1541::Idle compares
+      # it at two instruction boundaries.
+      def idle_state
+        [@program_counter, @stack_pointer, @a, @x, @y, @status.value,
+         @irq, @nmi, @irq_sample, @irq_pending, @nmi_sample, @nmi_pending, @skip_poll,
+         @boundary_irq, @boundary_nmi, @so_high, @interrupt, @brk, @pending_write, @stalled_at, @traps,
+         @operation, @optional_dummy, @boundary_crossed, @branch_taken,
+         @address, @pointer, @dummy_address, @value, @rmw_result]
+      end
+
+      # Counts +cycles+ cycles and +instructions+ instructions that ran
+      # without changing anything idle_state holds.
+      def fast_forward(cycles, instructions)
+        @cycles += cycles
+        @instructions += instructions
+      end
+    end
+  end
+end

data/lib/badline/drive1541.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "badline/drive1541/bus"
+require "badline/drive1541/cpu"
 require "badline/drive1541/serial_port"
 require "badline/drive1541/gcr"
 require "badline/drive1541/track"

data/lib/badline/ffi.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require "fiddle"
+
+module Badline
+  # The part of Spinel's FFI DSL the SDL binding uses, for CRuby, over
+  # Fiddle, so the one binding in badline/sdl serves both builds. Spinel
+  # compiles the declarations itself and never loads this file: require it
+  # before a file that declares a binding.
+  #
+  # The declarations behave as they do in Spinel. ffi_func defines
+  # Module.name(...); a pointer argument takes nil for NULL, a Fiddle
+  # pointer, a String (its bytes) or an IO::Buffer, whose contents C sees
+  # for the call's duration; a NULL pointer comes back as nil. ffi_const
+  # sets Module::NAME, ffi_buffer defines Module.name returning a zeroed
+  # static buffer, and ffi_read_<width> and ffi_write_<width> define field
+  # accessors at a fixed offset into a pointer.
+  module FFI
+    class Error < StandardError; end
+
+    TYPES = {
+      void: Fiddle::TYPE_VOID,
+      int: Fiddle::TYPE_INT, bool: Fiddle::TYPE_INT, long: Fiddle::TYPE_LONG, size_t: Fiddle::TYPE_SIZE_T,
+      int8: Fiddle::TYPE_INT8_T, uint8: Fiddle::TYPE_UINT8_T, int16: Fiddle::TYPE_INT16_T,
+      uint16: Fiddle::TYPE_UINT16_T, int32: Fiddle::TYPE_INT32_T, uint32: Fiddle::TYPE_UINT32_T,
+      float: Fiddle::TYPE_FLOAT, double: Fiddle::TYPE_DOUBLE,
+      str: Fiddle::TYPE_CONST_STRING,
+      ptr: Fiddle::TYPE_VOIDP, buffer_in: Fiddle::TYPE_VOIDP, buffer_out: Fiddle::TYPE_VOIDP,
+      buffer_inout: Fiddle::TYPE_VOIDP, int_array: Fiddle::TYPE_VOIDP, float_array: Fiddle::TYPE_VOIDP
+    }.freeze
+
+    # The argument specs C may write through, so an IO::Buffer passed in one
+    # gets back what C left in it.
+    WRITABLE = %i[ptr buffer_out buffer_inout].freeze
+
+    # pack directives for the accessor widths, in the host's byte order.
+    WIDTHS = {
+      u8: "C", i8: "c", u16: "S", i16: "s", u32: "L", i32: "l", u64: "Q", i64: "q", ptr: "J"
+    }.freeze
+
+    # Where dlopen looks for a library besides its search path, which leaves
+    # out Homebrew's, and the versioned names a runtime package installs
+    # without the development package's unversioned link.
+    DIRECTORIES = [nil, "/opt/homebrew/lib", "/usr/local/lib"].freeze
+    VERSIONED = { "SDL2" => %w[libSDL2-2.0.so.0 libSDL2-2.0.0.dylib] }.freeze
+
+    module_function
+
+    def open_library(name)
+      candidates = library_candidates(name)
+      candidates.each do |candidate|
+        return Fiddle.dlopen(candidate)
+      rescue Fiddle::DLError
+        next
+      end
+      raise Error, "can't find lib#{name} (tried #{candidates.join(', ')})"
+    end
+
+    def library_candidates(name)
+      names = ["lib#{name}.dylib", "lib#{name}.so", *VERSIONED.fetch(name, []), "#{name}.dll"]
+      DIRECTORIES.flat_map { |dir| names.map { |file| dir ? File.join(dir, file) : file } }
+    end
+
+    # The value Fiddle passes for one argument, and a block that copies what
+    # C wrote back into an IO::Buffer once the call returns.
+    def argument(spec, value)
+      case value
+      when IO::Buffer then buffer_argument(spec, value)
+      when Array then [value.pack(spec == :float_array ? "d*" : "q*")]
+      when true, false then [value ? 1 : 0]
+      else [value]
+      end
+    end
+
+    def buffer_argument(spec, buffer)
+      return [nil] if buffer.null? || buffer.empty?
+
+      bytes = buffer.get_string
+      return [bytes] unless WRITABLE.include?(spec) && !buffer.readonly?
+
+      [bytes, -> { buffer.set_string(bytes) }]
+    end
+
+    def result(spec, value)
+      case spec
+      when :ptr then value.null? ? nil : value
+      when :bool then value != 0
+      else value
+      end
+    end
+
+    def read(pointer, offset, width)
+      value = Fiddle::Pointer[pointer][offset, width_size(width)].unpack1(WIDTHS.fetch(width))
+      width == :ptr ? result(:ptr, Fiddle::Pointer.new(value)) : value
+    end
+
+    def write(pointer, offset, width, value)
+      value = value.to_i if width == :ptr
+      Fiddle::Pointer[pointer][offset, width_size(width)] = [value || 0].pack(WIDTHS.fetch(width))
+      value
+    end
+
+    def width_size(width) = [0].pack(WIDTHS.fetch(width)).bytesize
+
+    # The declarations, private methods of every module once this file is
+    # loaded, as they are keywords of a module body in Spinel.
+    module DSL
+      private
+
+      def ffi_lib(name)
+        (@ffi_libraries ||= []) << FFI.open_library(name)
+      end
+
+      def ffi_func(name, arguments, returns, blocking: false)
+        function = Fiddle::Function.new(ffi_symbol(name), arguments.map { |spec| TYPES.fetch(spec) },
+                                        TYPES.fetch(returns), name: name.to_s, need_gvl: !blocking)
+        define_singleton_method(name) do |*values|
+          converted = arguments.zip(values).map { |spec, value| FFI.argument(spec, value) }
+          returned = function.call(*converted.map(&:first))
+          converted.each { |argument| argument[1]&.call }
+          FFI.result(returns, returned)
+        end
+      end
+
+      def ffi_const(name, value)
+        const_set(name, value)
+      end
+
+      def ffi_buffer(name, size)
+        buffer = Fiddle::Pointer.malloc(size, Fiddle::RUBY_FREE)
+        buffer[0, size] = "\0" * size
+        define_singleton_method(name) { buffer }
+      end
+
+      WIDTHS.each_key do |width|
+        define_method(:"ffi_read_#{width}") do |name, offset|
+          define_singleton_method(name) { |pointer| FFI.read(pointer, offset, width) }
+        end
+
+        define_method(:"ffi_write_#{width}") do |name, offset|
+          define_singleton_method(name) { |pointer, value| FFI.write(pointer, offset, width, value) }
+        end
+      end
+
+      def ffi_symbol(name)
+        (@ffi_libraries || []).each do |library|
+          return library[name.to_s]
+        rescue Fiddle::DLError
+          next
+        end
+        Fiddle::Handle::DEFAULT[name.to_s]
+      end
+    end
+  end
+end
+
+Module.include(Badline::FFI::DSL)