zemu 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e21eb92ebce3eb8f03d9a17ddaec4f857989216a673791267602c0eb848319c7
-  data.tar.gz: 3ff049b8e132ae33a3376f21768378f06d6bd59b8f5014b81ede14f50e37eda6
+  metadata.gz: caa59294431c1faadda8328bc7fbefa504526ae43a5531e2cf1d6c2bc7dd5c87
+  data.tar.gz: 72ced5e284f94e586862e80e97f5d95f55a9a3dbc931dc889fdc73352cef3a82
 SHA512:
-  metadata.gz: 34706fc39b8212b6b3a07e077f5cd63479550e1832509bb01f742f86928c8c79844ce9689d4a11d79a2664d4ac13c6433f8a502b8806bf5e3390110009a27237
-  data.tar.gz: 74082dc5aad00935a79f3af11db3b288179015ddce3ce4cbd96439771cd1bce4377f08cc069c23574474942dc4ba5dff736c44cc7cc263df0a6a007e715a6fe0
+  metadata.gz: dbb449fa4a076320a3073391f98687098e4e0f8b484099a7ca2c67325f857e8923397267dc01c5bee521cf66e9457149a8845e15f4a8b74ae7962e1f84623ae1
+  data.tar.gz: 846f7d09837e09fdb5711ba7d3ee09ca734cf0454c10efaff77a2d92de742e88332cc2c3e008db7026c528460368e410c9c9ebaacf29694e513880255085d579

data/lib/zemu/config.rb

@@ -439,6 +439,215 @@ module Zemu
             end
         end
 
+        # Block drive object
+        #
+        # Represents a device with a sequence of sectors of a fixed size,
+        # which can be accessed via IO instructions as an IDE drive.
+        class BlockDrive < IOPort
+            # Constructor.
+            #
+            # Takes a block in which the parameters of the block drive
+            # can be initialized.
+            #
+            # All parameters can be set within this block.
+            # They become readonly as soon as the block completes.
+            #
+            # Constructor raises RangeError if a file is provided for initialization
+            # and it is of the wrong size.
+            #
+            # @example
+            #   
+            #   Zemu::Config::BlockDrive.new do
+            #       name "drive"
+            #       base_port 0x0c
+            #       sector_size 512
+            #       num_sectors 64
+            #   end
+            #
+            #
+            def initialize
+                @blocks = []
+                @initialize_from = nil
+
+                super
+
+                num_sectors.times do
+                    sector = []
+                    sector_size.times do
+                        sector << 0
+                    end
+                    @blocks << sector
+                end
+                
+                # Initialize from provided file if applicable.
+                unless @initialize_from.nil?
+                    # Check file size.
+                    file_size = File.size(@initialize_from)
+                    if (file_size != num_sectors * sector_size)
+                        raise RangeError, "Initialization file for Zemu::Config::BlockDrive '#{name}' is of wrong size."
+                    end
+
+                    File.open(@initialize_from, "rb") do |f|
+                        num_sectors.times do |s|
+                            sector_size.times do |b|
+                                @blocks[s][b] = f.getbyte()
+                            end
+                        end
+                    end
+                end
+
+                when_setup do
+<<-eos
+#include <stdio.h>
+
+zuint8 sector_data_#{name}[#{sector_size}];
+zuint32 sector_data_#{name}_offset;
+zuint32 loaded_sector_#{name} = Z_UINT32_MAXIMUM;
+zuint8 drive_mode_#{name};
+zuint8 drive_status_#{name} = 0b01000000;
+
+zuint8 lba_#{name}_0;
+zuint8 lba_#{name}_1;
+zuint8 lba_#{name}_2;
+zuint8 lba_#{name}_3;
+
+void internal_#{name}_load_sector(zuint32 sector)
+{
+    if (loaded_sector_#{name} == sector) return;
+
+    FILE * fptr = fopen("#{@initialize_from}", "rb");
+    fseek(fptr, sector * #{sector_size}, SEEK_SET);
+    fread(sector_data_#{name}, #{sector_size}, 1, fptr);
+    fclose(fptr);
+
+    loaded_sector_#{name} = sector;
+}
+
+void internal_#{name}_write_current_sector()
+{
+    FILE * fptr = fopen("#{@initialize_from}", "r+b");
+    fseek(fptr, loaded_sector_#{name} * #{sector_size}, SEEK_SET);
+    fwrite(sector_data_#{name}, 1, #{sector_size}, fptr);
+    fclose(fptr);
+}
+
+zuint8 zemu_io_#{name}_readbyte(zuint32 sector, zuint32 offset)
+{
+    internal_#{name}_load_sector(sector);
+    return sector_data_#{name}[offset];
+}
+eos
+                end
+
+                when_read do
+<<-eos
+if (port == #{base_port})
+{
+    zuint8 b = sector_data_#{name}[sector_data_#{name}_offset];
+    sector_data_#{name}_offset++;
+    if (sector_data_#{name}_offset >= #{sector_size})
+    {
+        drive_status_#{name} = 0b01000000;
+    }
+    return b;
+}
+else if (port == #{base_port+7})
+{
+    return drive_status_#{name};
+}
+eos
+                end
+
+                when_write do
+<<-eos
+if (port == #{base_port})
+{
+    if (drive_mode_#{name} == 0x01)
+    {
+        sector_data_#{name}[sector_data_#{name}_offset] = value;
+        sector_data_#{name}_offset++;
+        if (sector_data_#{name}_offset >= #{sector_size})
+        {
+            internal_#{name}_write_current_sector();
+            drive_status_#{name} = 0b01000000;
+        }
+    }
+}
+else if (port == #{base_port+3})
+{
+    lba_#{name}_0 = value;
+}
+else if (port == #{base_port+4})
+{
+    lba_#{name}_1 = value;
+}
+else if (port == #{base_port+5})
+{
+    lba_#{name}_2 = value;
+}
+else if (port == #{base_port+6})
+{
+    lba_#{name}_3 = value & 0b00011111;
+}
+else if (port == #{base_port+7})
+{
+    if (value == 0x20)
+    {
+        zuint32 sector = 0;
+        sector |= (zuint32)lba_#{name}_3 << 24;
+        sector |= (zuint32)lba_#{name}_2 << 16;
+        sector |= (zuint32)lba_#{name}_1 << 8;
+        sector |= (zuint32)lba_#{name}_0;
+
+        internal_#{name}_load_sector(sector);
+        sector_data_#{name}_offset = 0;
+
+        drive_mode_#{name} = 0x00;
+        drive_status_#{name} = 0b00001000;
+    }
+    else if (value == 0x30)
+    {
+        zuint32 sector = 0;
+        sector |= (zuint32)lba_#{name}_3 << 24;
+        sector |= (zuint32)lba_#{name}_2 << 16;
+        sector |= (zuint32)lba_#{name}_1 << 8;
+        sector |= (zuint32)lba_#{name}_0;
+
+        internal_#{name}_load_sector(sector);
+        sector_data_#{name}_offset = 0;
+
+        drive_mode_#{name} = 0x01;
+        drive_status_#{name} = 0b00001000;
+    }
+}
+eos
+                end
+            end
+
+            # Array of sectors of this drive.
+            def blocks
+                @blocks
+            end
+
+            # Set file to initialize from.
+            def initialize_from(file)
+                @initialize_from = file
+            end
+
+            # Defines FFI API which will be available to the instance wrapper if this IO device is used.
+            def functions
+                [
+                    {"name" => "zemu_io_#{name}_readbyte", "args" => [:uint32, :uint32], "return" => :uint8},
+                ]
+            end
+
+            # Valid parameters for a BlockDrive, along with those
+            # defined in [Zemu::Config::IOPort].
+            def params
+                super + %w(base_port sector_size num_sectors)
+            end
+        end
+
         # Non-Maskable Interrupt Timer
         #
         # Represents a timer device, the period of which can be controlled
@@ -490,7 +699,7 @@ module Zemu
 
         # Parameters accessible by this configuration object.
         def params
-            return %w(name compiler output_directory clock_speed)
+            return %w(name compiler output_directory clock_speed serial_delay)
         end
 
         # Initial value for parameters of this configuration object.
@@ -498,7 +707,8 @@ module Zemu
             return {
                 "compiler" => "clang",
                 "output_directory" => "bin",
-                "clock_speed" => 0
+                "clock_speed" => 0,
+                "serial_delay" => 0
             }
         end
 

data/lib/zemu/debug.rb

@@ -0,0 +1,68 @@
+module Zemu
+    # Handles debugging functionality, like mapping of symbols to addresses,
+    # disassembling of instructions, etc.
+    module Debug
+        # Loads a map file at the given path, and returns a hash of address => Symbol
+        # for the symbols defined within.
+        def self.load_map(path)
+            symbols = {}
+
+            File.open(path, "r") do |f|
+                f.each_line do |l|
+                    s = Symbol.parse(l)
+
+                    if symbols[s.address].nil?
+                        symbols[s.address] = []
+                    end
+
+                    symbols[s.address] << s
+                    symbols[s.address].sort_by!(&:label)
+                end
+            end
+
+            return symbols
+        end
+        
+        # Represents a symbol definition, of the form `label = address`.
+        class Symbol
+            # Parse a symbol definition, returning a Symbol instance.
+            def self.parse(s)
+                # Split on whitespace.
+                tokens = s.to_s.split(' ')
+
+                if tokens.size < 3
+                    raise ArgumentError, "Invalid symbol definition: '#{s}'"
+                end
+
+                label = tokens[0]
+
+                address = nil
+
+                if /0x[0-9a-fA-F]+/ =~ tokens[2]
+                    address = tokens[2][2..-1].to_i(16)
+                elsif /\$[0-9a-fA-F]+/ =~ tokens[2]
+                    address = tokens[2][1..-1].to_i(16)
+                elsif /\d+/ =~ tokens[2]
+                    address = tokens[2].to_i
+                end
+
+                if address.nil?
+                    raise ArgumentError, "Invalid symbol address: '#{tokens[2]}'"
+                end
+
+                return self.new(label, address)
+            end
+
+            # Textual label for this symbol.
+            attr_reader :label
+
+            # Address of this symbol in the binary.
+            attr_reader :address
+
+            def initialize(label, address)
+                @label = label
+                @address = address
+            end
+        end
+    end
+end

data/lib/zemu/instance.rb

@@ -54,6 +54,7 @@ module Zemu
 
         def initialize(configuration)
             @clock = configuration.clock_speed
+            @serial_delay = configuration.serial_delay
 
             @wrapper = make_wrapper(configuration)
 
@@ -65,7 +66,7 @@ module Zemu
 
             @state = RunState::UNDEFINED
 
-            @breakpoints = []
+            @breakpoints = {}
         end
 
         # Returns the clock speed of this instance in Hz.
@@ -73,6 +74,11 @@ module Zemu
             return @clock
         end
 
+        # Returns the delay between characters on the serial port for this instance in seconds.
+        def serial_delay
+            return @serial_delay
+        end
+
         # Returns a hash containing current values of the emulated
         # machine's registers. All names are as those given in the Z80
         # reference manual.
@@ -136,6 +142,16 @@ module Zemu
             return return_string
         end
 
+        # Get a byte from the attached disk drive.
+        #
+        # @param sector The sector to read
+        # @param offset The offset in sector to read
+        #
+        # Gets a byte at the given offset in the given sector.
+        def drive_readbyte(sector, offset)
+            return @wrapper.zemu_io_block_drive_readbyte(sector, offset)
+        end
+
         # Continue running this instance until either:
         # * A HALT instruction is executed
         # * A breakpoint is hit
@@ -161,7 +177,7 @@ module Zemu
 
                 # If the PC is now pointing to one of our breakpoints,
                 # we're in the BREAK state.
-                if (@breakpoints.select { |b| b == pc }.size) > 0
+                if @breakpoints[pc]
                     @state = RunState::BREAK
                 elsif @wrapper.zemu_debug_halted()
                     @state = RunState::HALTED
@@ -177,7 +193,7 @@ module Zemu
         # @param type The type of breakpoint:
         #   * :program => Break when the program counter hits the address given. 
         def break(address, type)
-            @breakpoints << address
+            @breakpoints[address] = true
         end
 
         # Remove a breakpoint of the given type at the given address.
@@ -186,7 +202,7 @@ module Zemu
         # @param address The address of the breakpoint to be removed.
         # @param type The type of breakpoint. See Instance#break.
         def remove_break(address, type)
-            @breakpoints.reject! { |b| b == address }
+            @breakpoints[address] = false
         end
 
         # Returns true if the CPU has halted, false otherwise.
@@ -232,7 +248,7 @@ module Zemu
 
             configuration.io.each do |device|
                 device.functions.each do |f|
-                    wrapper.attach_function(f["name"], f["args"], f["return"])
+                    wrapper.attach_function(f["name"].to_sym, f["args"], f["return"])
                 end
             end
 

data/lib/zemu/interactive.rb

@@ -8,6 +8,8 @@ module Zemu
         def initialize(instance)
             @instance = instance
 
+            @symbol_table = {}
+
             @master, @slave = PTY.open
             log "Opened PTY at #{@slave.path}"
         end
@@ -59,6 +61,9 @@ module Zemu
                         memory(cmd[1], cmd[2])
                     end
 
+                elsif cmd[0] == "map"
+                    load_map(cmd[1])
+
                 elsif cmd[0] == "help"
                     log "Available commands:"
                     log "    continue [<n>]     - Continue execution for <n> cycles"
@@ -66,6 +71,7 @@ module Zemu
                     log "    registers          - View register contents"
                     log "    memory <a> [<n>]   - View <n> bytes of memory, starting at address <a>."
                     log "                         <n> defaults to 1 if omitted."
+                    log "    map <path>         - Load symbols from map file at <path>"
                     log "    break  <a>         - Set a breakpoint at the given address <a>."
                     log "    quit               - End this emulator instance."
 
@@ -79,16 +85,53 @@ module Zemu
         end
 
         # Outputs a table giving the current values of the instance's registers.
+        # For the 16-bit registers (BC, DE, HL, IX, IY, SP, PC), attempts to identify the symbol
+        # to which they point.
         def registers
             log "A:  #{r("A")} F: #{r("F")}"
-            log "B:  #{r("B")} C: #{r("C")}"
-            log "D:  #{r("D")} E: #{r("E")}"
-            log "H:  #{r("H")} L: #{r("L")}"
+
+            registers_gp('B', 'C')
+            registers_gp('D', 'E')
+            registers_gp('H', 'L')
+
             log ""
-            log "IX: #{r16("IX")}"
-            log "IY: #{r16("IY")}"
-            log "SP: #{r16("SP")}"
-            log "PC: #{r16("PC")}"
+
+            register_16("IX")
+            register_16("IY")
+            register_16("SP")
+            register_16("PC")
+        end
+
+        # Displays the value of a 16-bit register.
+        def register_16(r)
+            value = @instance.registers[r]
+
+            log "#{r}: #{r16(r)} (#{get_symbol(value)})"
+        end
+
+        # Displays the value of a general-purpose 16-bit register pair.
+        def registers_gp(hi, lo)
+            value = hilo(@instance.registers[hi], @instance.registers[lo])
+
+            log "#{hi}:  #{r(hi)} #{lo}: #{r(lo)} (#{get_symbol(value)})"
+        end
+
+        # Gets the symbol associated with the given value.
+        # If no matching symbol, gives offset from previous symbol.
+        def get_symbol(value)
+            syms = nil
+            addr = value
+            while addr > 0 do
+                syms = @symbol_table[addr]
+                break unless syms.nil?
+                addr -= 1
+            end
+
+            sym = if syms.nil? then nil else syms[0] end
+
+            sym_str = "<#{if sym.nil? then 'undefined' else sym.label end}#{if addr == value then '' else "+#{value-addr}" end}>"
+
+            return sym_str
         end
 
         # Returns a particular 8-bit register value.
@@ -101,6 +144,11 @@ module Zemu
             return "0x%04x" % @instance.registers[reg]
         end
 
+        # Concatenates two 8-bit values, in big-endian format.
+        def hilo(hi, lo)
+            return (hi << 8) | lo
+        end
+
         # Continue for *up to* the given number of cycles.
         # Fewer cycles may be executed, depending on the behaviour of the processor.
         def continue(cycles=-1)
@@ -114,13 +162,19 @@ module Zemu
             cycles_left = cycles
             actual_cycles = 0
 
+            serial_count = @instance.serial_delay.to_f
+
             while ((cycles == -1) || (cycles_left > 0))
                 # Get time before execution.
                 start = Time.now
 
                 old_pc = r16("PC")
 
-                process_serial
+                if (serial_count >= @instance.serial_delay)
+                    process_serial
+                    serial_count = 0.0
+                end
+
                 cycles_done = @instance.continue(1)
                 cycles_left -= cycles_done
                 actual_cycles += cycles_done
@@ -132,7 +186,9 @@ module Zemu
                 if @instance.clock_speed > 0
                     elapsed = ending - start
 
-                    execution_time = cycles_done * (1/@instance.clock_speed)
+                    execution_time = cycles_done * (1.0/@instance.clock_speed)
+                    serial_count += execution_time
+                    
                     padding = execution_time - elapsed
                     sleep(padding) unless padding < 0
                 end
@@ -169,7 +225,7 @@ module Zemu
             
             (address.to_i(16)...address.to_i(16) + size.to_i(16)).each do |a|
                 m = @instance.memory(a)
-                if (m < 32)
+                if (m < 32 || m > 126)
                     log "%04x: %02x    ." % [a, m]
                 else
                     log ("%04x: %02x    " % [a, m]) + m.chr("UTF-8")
@@ -177,6 +233,34 @@ module Zemu
             end
         end
 
+        # Loads a MAP file from the given path.
+        def load_map(path)
+            if path.nil?
+                log "No path specified."
+                return
+            end
+
+            unless File.exist?(path.to_s)
+                log "Map file '#{path}' does not exist."
+                return
+            end
+
+            if File.directory?(path.to_s)
+                log "Cannot open '#{path}': it is a directory."
+                return
+            end
+
+            syms = {}
+            begin
+                syms.merge! Debug.load_map(path.to_s)
+            rescue ArgumentError => e
+                log "Error loading map file: #{e.message}"
+                syms.clear
+            end
+
+            @symbol_table.merge! syms
+        end
+
         # Process serial input/output via the TTY.
         def process_serial
             # Read/write serial.

data/lib/zemu.rb

@@ -5,6 +5,7 @@ require 'pty'
 require_relative 'zemu/config'
 require_relative 'zemu/instance'
 require_relative 'zemu/interactive'
+require_relative 'zemu/debug'
 
 # Zemu is a module providing an interface to build and interact with
 # configurable Z80 emulators.
@@ -128,7 +129,7 @@ module Zemu
 
         includes_str += " -I" + autogen
 
-        command = "#{compiler} -Werror -Wno-unknown-warning-option -fPIC -shared -Wl,-undefined -Wl,dynamic_lookup #{includes_str} #{defines_str} -o #{output} #{inputs_str}"
+        command = "#{compiler} -O2 -Werror -Wno-unknown-warning-option -fPIC -shared -Wl,-undefined -Wl,dynamic_lookup #{includes_str} #{defines_str} -o #{output} #{inputs_str}"
         
         # Run the compiler and generate a library.
         return system(command)

data/src/io.c.erb

@@ -4,6 +4,21 @@
 <%= device.setup %>
 <% end %>
 
+void zemu_io_nmi(Z80 * instance)
+{
+    z80_nmi(instance);
+}
+
+void zemu_io_int_on(Z80 * instance)
+{
+    z80_int(instance, TRUE);
+}
+
+void zemu_io_int_off(Z80 * instance)
+{
+    z80_int(instance, FALSE);
+}
+
 zuint8 zemu_io_in(void * context, zuint16 port)
 {
     /* Z80 IO ports occupy the lower half of the address bus.
@@ -29,11 +44,6 @@ void zemu_io_out(void * context, zuint16 port, zuint8 value)
 <% end %>
 }
 
-void zemu_io_nmi(Z80 * instance)
-{
-    z80_nmi(instance);
-}
-
 void zemu_io_clock(Z80 * instance)
 {
 <% io.each do |device| %>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-23 00:00:00.000000000 Z
+date: 2021-10-23 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system
@@ -29,6 +29,7 @@ extra_rdoc_files: []
 files:
 - lib/zemu.rb
 - lib/zemu/config.rb
+- lib/zemu/debug.rb
 - lib/zemu/instance.rb
 - lib/zemu/interactive.rb
 - src/debug.c
@@ -333,8 +334,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: A configurable Z80 emulator.