zemu 0.4.2 → 1.1.0

data/lib/zemu/debug.rb

@@ -5,22 +5,55 @@ module Zemu
         # 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 = {}
+            symbols = []
 
             File.open(path, "r") do |f|
                 f.each_line do |l|
                     s = Symbol.parse(l)
 
-                    if symbols[s.address].nil?
-                        symbols[s.address] = []
+                    symbols << s
+                end
+            end
+
+            return Symbols.new(symbols)
+        end
+
+        # Contains a set of symbols.
+        # Allows for various lookup operations.
+        class Symbols
+            # Constructor.
+            def initialize(syms)
+                @syms = []
+                syms.each do |s|
+                    @syms << s
+                end
+            end
+
+            # Access all symbols with a given address.
+            def [](address)
+                at_address = []
+                @syms.each do |s|
+                    if s.address == address
+                        at_address << s
                     end
+                end
+
+                return at_address.sort_by(&:label)
+            end
 
-                    symbols[s.address] << s
-                    symbols[s.address].sort_by!(&:label)
+            # Find a symbol with a given name.
+            def find_by_name(name)
+                @syms.each do |s|
+                    return s if s.label == name
                 end
+
+                return nil
             end
 
-            return symbols
+            # Get symbols as a hash.
+            def hash
+                return @syms
+            end
         end
         
         # Represents a symbol definition, of the form `label = address`.

data/lib/zemu/instance.rb

@@ -2,6 +2,17 @@ require 'ffi'
 require 'ostruct'
 
 module Zemu
+    # Exception raised when an error occurs in a Zemu::Instance.
+    class InstanceError < StandardError
+        # Constructor.
+        #
+        # @param msg    The exception message
+        #
+        def initialize(msg="An error occurred with the Zemu::Instance")
+            super
+        end
+    end
+
     # Represents an instance of a Zemu emulator.
     #
     # Provides methods by which the state of the emulator can be observed
@@ -61,9 +72,11 @@ module Zemu
         end
 
         def initialize(configuration)
-            # Methods defined by IO devices that we make
+            @devices = configuration.devices
+
+            # Methods defined by bus devices that we make
             # accessible to the user.
-            @io_methods = []
+            @device_methods = []
 
             @clock = configuration.clock_speed
             @serial_delay = configuration.serial_delay
@@ -73,12 +86,95 @@ module Zemu
             @serial = []
 
             @instance = @wrapper.zemu_init
+
+            # Declare handlers.
+            # Memory write handler.
+            @mem_write = Proc.new do |addr, value|
+                @devices.each do |d|
+                    d.mem_write(addr, value)
+                end
+            end
+
+            # Memory read handler.
+            @mem_read = Proc.new do |addr|
+                r = 0
+                @devices.each do |d|
+                    v = d.mem_read(addr)
+                    unless v.nil?
+                        r = v
+                        break
+                    end
+                end
+
+                r
+            end
+
+            # IO write handler.
+            @io_write = Proc.new do |port, value|
+                @devices.each do |d|
+                    d.io_write(port, value)
+                end
+            end
+
+            # IO read handler.
+            @io_read = Proc.new do |port|
+                r = 0
+                @devices.each do |d|
+                    v = d.io_read(port)
+                    unless v.nil?
+                        r = v
+                        break
+                    end
+                end
+
+                r
+            end
+
+            # IO read handler.
+            @io_clock = Proc.new do |cycles|
+                @devices.each do |d|
+                    d.clock(cycles)
+                end
+
+                bus_state = 0
+
+                if @devices.any? { |d| d.nmi? }
+                    bus_state |= 1
+                end
+
+                if @devices.any? { |d| d.interrupt? }
+                    bus_state |= 2
+                end
+
+                bus_state
+            end
+
+            # Attach handlers.
+            @wrapper.zemu_set_mem_write_handler(@mem_write)
+            @wrapper.zemu_set_mem_read_handler(@mem_read)
+            @wrapper.zemu_set_io_write_handler(@io_write)
+            @wrapper.zemu_set_io_read_handler(@io_read)
+            @wrapper.zemu_set_io_clock_handler(@io_clock)
+
             @wrapper.zemu_power_on(@instance)
             @wrapper.zemu_reset(@instance)
 
             @state = RunState::UNDEFINED
 
             @breakpoints = {}
+            @tracepoints = {}
+        end
+
+        # Returns the device with the given name, or nil
+        # if no such device exists.
+        def device(name)
+            @devices.each do |d|
+                if d.name == name
+                    return d
+                end
+            end
+
+            nil
         end
 
         # Returns the clock speed of this instance in Hz.
@@ -141,7 +237,7 @@ module Zemu
         # emulated machine.
         def serial_puts(string)
             string.each_char do |c|
-                @wrapper.zemu_io_serial_master_puts(c.ord)
+                device('serial').put_byte(c.ord)
             end
         end
 
@@ -157,14 +253,14 @@ module Zemu
         def serial_gets(count=nil)
             return_string = ""
 
-            actual_count = @wrapper.zemu_io_serial_buffer_size()
+            actual_count = device('serial').transmitted_count()
 
             if count.nil? || actual_count < count
                 count = actual_count
             end
 
             count.to_i.times do
-                return_string += @wrapper.zemu_io_serial_master_gets().chr
+                return_string += device('serial').get_byte().chr
             end
 
             return return_string
@@ -203,6 +299,12 @@ module Zemu
 
                 pc = @wrapper.zemu_debug_pc(@instance)
 
+                # If there's a tracepoint at this address,
+                # execute the associated proc.
+                unless @tracepoints[pc].nil?
+                    @tracepoints[pc].call(self)
+                end
+
                 # If the PC is now pointing to one of our breakpoints,
                 # we're in the BREAK state.
                 if @breakpoints[pc]
@@ -224,6 +326,26 @@ module Zemu
             @breakpoints[address] = true
         end
 
+        # Set a tracepoint to execute the given block at an address.
+        #
+        # @param address The address of the tracepoint
+        # @param block   The block to execute at the tracepoint.
+        #                The block takes the instance as a parameter.
+        #
+        # @example
+        #     instance.trace(0x1234) do |i|
+        #         puts "HL value: 04x" % i.registers["HL"]
+        #     end
+        #
+        def trace(address, &block)
+            if block.arity != 1
+                raise InstanceError,
+                      "Wrong arity for tracepoint - expected 1, got #{block.arity}"
+            end
+            
+            @tracepoints[address] = block
+        end
+
         # Remove a breakpoint of the given type at the given address.
         # Does nothing if no breakpoint previously existed at that address.
         #
@@ -257,6 +379,21 @@ module Zemu
 
             wrapper.ffi_lib [File.join(configuration.output_directory, "#{configuration.name}.so")]
 
+            # Handler types for handling bus accesses.
+            wrapper.callback :mem_write_handler, [:uint32, :uint8], :void
+            wrapper.callback :mem_read_handler, [:uint32], :uint8
+
+            wrapper.callback :io_write_handler, [:uint8, :uint8], :void
+            wrapper.callback :io_read_handler, [:uint8], :uint8
+            wrapper.callback :io_clock_handler, [:uint64], :uint8
+
+            wrapper.attach_function :zemu_set_mem_write_handler, [:mem_write_handler], :void
+            wrapper.attach_function :zemu_set_mem_read_handler, [:mem_read_handler], :void
+
+            wrapper.attach_function :zemu_set_io_write_handler, [:io_write_handler], :void
+            wrapper.attach_function :zemu_set_io_read_handler, [:io_read_handler], :void
+            wrapper.attach_function :zemu_set_io_clock_handler, [:io_clock_handler], :void
+
             wrapper.attach_function :zemu_init, [], :pointer
             wrapper.attach_function :zemu_free, [:pointer], :void
 
@@ -275,10 +412,10 @@ module Zemu
             wrapper.attach_function :zemu_debug_get_memory, [:uint16], :uint8
             wrapper.attach_function :zemu_debug_set_memory, [:uint16, :uint8], :void
 
-            configuration.io.each do |device|
+            configuration.devices.each do |device|
                 device.functions.each do |f|
                     wrapper.attach_function(f["name"].to_sym, f["args"], f["return"])
-                    @io_methods << f["name"].to_sym
+                    @device_methods << f["name"].to_sym
                 end
             end
 
@@ -287,7 +424,7 @@ module Zemu
 
         # Redirects calls to I/O FFI functions.
         def method_missing(method, *args)
-            if @io_methods.include? method
+            if @device_methods.include? method
                 return @wrapper.send(method)
             end
 

data/lib/zemu/interactive.rb

@@ -11,6 +11,7 @@ module Zemu
         #                      to the emulator window.
         def initialize(instance, options = {})
             @print_serial = options[:print_serial]
+            @trace = []
 
             @instance = instance
 
@@ -70,6 +71,9 @@ module Zemu
                 elsif cmd[0] == "map"
                     load_map(cmd[1])
 
+                elsif cmd[0] == "trace"
+                    trace()
+
                 elsif cmd[0] == "help"
                     log "Available commands:"
                     log "    continue [<n>]     - Continue execution for <n> cycles"
@@ -90,6 +94,14 @@ module Zemu
             close
         end
 
+        # Print trace for the emulator instance
+        # (last 200 addresses visited).
+        def trace
+            @trace.each do |t|
+                puts "%04x" % t
+            end
+        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.
@@ -171,9 +183,6 @@ module Zemu
             serial_count = @instance.serial_delay.to_f
 
             while ((cycles == -1) || (cycles_left > 0))
-                # Get time before execution.
-                start = Time.now
-
                 old_pc = r16("PC")
 
                 if (serial_count >= @instance.serial_delay)
@@ -185,18 +194,10 @@ module Zemu
                 cycles_left -= cycles_done
                 actual_cycles += cycles_done
 
-                # Get time after execution.
-                ending = Time.now
-
                 # Get elapsed time and calculate padding time to match clock speed.
                 if @instance.clock_speed > 0
-                    elapsed = ending - start
-
                     execution_time = cycles_done * (1.0/@instance.clock_speed)
                     serial_count += execution_time
-                    
-                    padding = execution_time - elapsed
-                    sleep(padding) unless padding < 0
                 end
 
                 # Have we hit a breakpoint or HALT instruction?
@@ -258,7 +259,7 @@ module Zemu
 
             syms = {}
             begin
-                syms.merge! Debug.load_map(path.to_s)
+                syms.merge! Debug.load_map(path.to_s).hash
             rescue ArgumentError => e
                 log "Error loading map file: #{e.message}"
                 syms.clear

data/lib/zemu.rb

@@ -111,7 +111,7 @@ module Zemu
 
         inputs_str = inputs.map { |i| File.join(SRC, i) }.join(" ")
 
-        inputs_str += " " + File.join(autogen, "memory.c") + " " + File.join(autogen, "io.c")
+        inputs_str += " " + File.join(autogen, "bus.c")
 
         defines = {
             "CPU_Z80_STATIC" => 1,
@@ -143,14 +143,13 @@ module Zemu
     #
     # @param [Zemu::Config] configuration The configuration for which an emulator will be generated.
     def Zemu::generate(configuration)
-        generate_memory(configuration)
-        generate_io(configuration)
+        generate_bus(configuration)
     end
 
-    # Generates the memory.c and memory.h files for a given configuration.
-    def Zemu::generate_memory(configuration)
-        header_template = ERB.new File.read(File.join(SRC, "memory.h.erb"))
-        source_template = ERB.new File.read(File.join(SRC, "memory.c.erb"))
+    # Generates the bus.c and bus.h files for a given configuration.
+    def Zemu::generate_bus(configuration)
+        header_template = ERB.new File.read(File.join(SRC, "bus.h.erb"))
+        source_template = ERB.new File.read(File.join(SRC, "bus.c.erb"))
 
         autogen = File.join(configuration.output_directory, "autogen_#{configuration.name}")
 
@@ -158,28 +157,10 @@ module Zemu
             Dir.mkdir autogen
         end
 
-        File.write(File.join(autogen, "memory.h"),
+        File.write(File.join(autogen, "bus.h"),
                    header_template.result(configuration.get_binding))
 
-        File.write(File.join(autogen, "memory.c"),
-                   source_template.result(configuration.get_binding))
-    end
-
-    # Generates the io.c and io.h files for a given configuration.
-    def Zemu::generate_io(configuration)
-        header_template = ERB.new File.read(File.join(SRC, "io.h.erb"))
-        source_template = ERB.new File.read(File.join(SRC, "io.c.erb"))
-
-        autogen = File.join(configuration.output_directory, "autogen_#{configuration.name}")
-
-        unless Dir.exist? autogen
-            Dir.mkdir autogen
-        end
-
-        File.write(File.join(autogen, "io.h"),
-                   header_template.result(configuration.get_binding))
-
-        File.write(File.join(autogen, "io.c"),
+        File.write(File.join(autogen, "bus.c"),
                    source_template.result(configuration.get_binding))
     end
 end

data/src/bus.c.erb

@@ -0,0 +1,119 @@
+#include "bus.h"
+
+mem_write_handler_t * mem_write_handler;
+mem_read_handler_t * mem_read_handler;
+
+io_write_handler_t * io_write_handler;
+io_read_handler_t * io_read_handler;
+io_clock_handler_t * io_clock_handler;
+
+<% devices.each do |d| %>
+<% next if d.memory.nil? %>
+<%= d.memory.setup %>
+<% end %>
+
+void zemu_set_mem_write_handler(mem_write_handler_t * h)
+{
+    mem_write_handler = h;
+}
+
+void zemu_set_mem_read_handler(mem_read_handler_t * h)
+{
+    mem_read_handler = h;
+}
+
+void zemu_set_io_write_handler(io_write_handler_t * h)
+{
+    io_write_handler = h;
+}
+
+void zemu_set_io_read_handler(io_read_handler_t * h)
+{
+    io_read_handler = h;
+}
+
+void zemu_set_io_clock_handler(io_clock_handler_t * h)
+{
+    io_clock_handler = h;
+}
+
+zuint8 zemu_memory_read(void * context, zuint16 address)
+{
+    return zemu_memory_peek(address);
+}
+
+void zemu_memory_write(void * context, zuint16 address, zuint8 value)
+{
+    zemu_memory_poke(address, value);
+}
+
+zuint8 zemu_memory_peek(zuint16 address)
+{
+    zuint32 address_32 = address;
+
+    <% devices.each do |d| %>
+    <% next if d.memory.nil? %>
+    if ((address_32 >= <%= d.memory.address %>) && (address_32 < <%= d.memory.address + d.memory.size%>))
+        return <%= d.memory.access_read %>[address_32 - <%= d.memory.address %>];
+    <% end %>
+
+    return mem_read_handler(address_32);
+}
+
+void zemu_memory_poke(zuint16 address, zuint8 value)
+{
+    zuint32 address_32 = address;
+    
+    <% devices.each do |d| %>
+    <% next if d.memory.nil? %>
+    if ((address_32 >= <%= d.memory.address %>) && (address_32 < <%= d.memory.address + d.memory.size%>))
+        <%= d.memory.access_write %>[address_32 - <%= d.memory.address %>] = value;
+    <% end %>
+
+    mem_write_handler(address_32, value);
+}
+
+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.
+     * We cannot assume that the top half is valid.
+     */
+    port &= 0x00FF;
+
+    return io_read_handler((zuint8)port);
+}
+
+void zemu_io_out(void * context, zuint16 port, zuint8 value)
+{
+    /* Z80 IO ports occupy the lower half of the address bus.
+     * We cannot assume that the top half is valid.
+     */
+    port &= 0x00FF;
+
+    io_write_handler((zuint8)port, value);
+}
+
+void zemu_io_clock(Z80 * instance, zusize cycles)
+{
+    zuint8 bus_state = io_clock_handler(cycles);
+
+    if (bus_state & 0x01) zemu_io_nmi(instance);
+    
+    if (bus_state & 0x02) zemu_io_int_on(instance);
+    else                  zemu_io_int_off(instance);
+}

data/src/bus.h.erb

@@ -0,0 +1,53 @@
+#ifndef _ZEMU_IO_H
+#define _ZEMU_IO_H
+
+#include "emulation/CPU/Z80.h"
+
+#ifndef ZEMU_IO_SERIAL_BUFFER_SIZE
+#define ZEMU_IO_SERIAL_BUFFER_SIZE 256
+#endif
+
+typedef struct {
+    zuint8 buffer[ZEMU_IO_SERIAL_BUFFER_SIZE];
+    unsigned int head;
+    unsigned int tail;
+} SerialBuffer;
+
+/* Type of a function writing to a memory address. */
+typedef void mem_write_handler_t(zuint32, zuint8);
+
+/* Type of a function reading from a memory address. */
+typedef zuint8 mem_read_handler_t(zuint32);
+
+/* Type of a function writing to an IO port. */
+typedef void io_write_handler_t(zuint8, zuint8);
+
+/* Type of a function reading from an IO port. */
+typedef zuint8 io_read_handler_t(zuint8);
+
+/* Type of a function to handle a clock cycle for a peripheral. */
+typedef zuint8 io_clock_handler_t(zusize);
+
+void zemu_set_mem_write_handler(mem_write_handler_t * h);
+void zemu_set_mem_read_handler(mem_read_handler_t * h);
+
+void zemu_set_io_write_handler(io_write_handler_t * h);
+void zemu_set_io_read_handler(io_read_handler_t * h);
+void zemu_set_io_clock_handler(io_clock_handler_t * h);
+
+zuint8 zemu_memory_read(void * context, zuint16 address);
+void zemu_memory_write(void * context, zuint16 address, zuint8 value);
+
+zuint8 zemu_memory_peek(zuint16 address);
+void zemu_memory_poke(zuint16 address, zuint8 value);
+
+void zemu_io_serial_master_puts(zuint8 val);
+zuint8 zemu_io_serial_master_gets(void);
+zusize zemu_io_serial_buffer_size(void);
+
+zuint8 zemu_io_in(void * context, zuint16 port);
+void zemu_io_out(void * context, zuint16 port, zuint8 value);
+void zemu_io_nmi(Z80 * instance);
+void zemu_io_clock(Z80 * instance, zusize cycles);
+
+#endif

data/src/debug.c

@@ -8,7 +8,7 @@ zusize zemu_debug_step(Z80 * instance)
     zusize cycles = z80_run(instance, 1);
 
     /* Execute the per-cycle behaviour of the peripheral devices. */
-    for (zusize i = 0; i < cycles; i++) zemu_io_clock(instance);
+    zemu_io_clock(instance, cycles);
 
     return cycles;
 }

data/src/debug.h

@@ -2,8 +2,7 @@
 
 #include <stdio.h>
 
-#include "memory.h"
-#include "io.h"
+#include "bus.h"
 
 zusize zemu_debug_step(Z80 * instance);
 

data/src/main.c

@@ -4,8 +4,7 @@
 
 #include "debug.h"
 
-#include "memory.h"
-#include "io.h"
+#include "bus.h"
 #include "interrupt.h"
 
 /* Allocate and initialize a Z80 instance.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: zemu
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 1.1.0
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-19 00:00:00.000000000 Z
+date: 2022-01-30 00:00:00.000000000 Z
 dependencies: []
 description: |2
       Zemu is a gem which allows the user to configure a Z80-based system
@@ -32,6 +32,8 @@ files:
 - lib/zemu/debug.rb
 - lib/zemu/instance.rb
 - lib/zemu/interactive.rb
+- src/bus.c.erb
+- src/bus.h.erb
 - src/debug.c
 - src/debug.h
 - src/external/Z/API/Z/ABIs/generic/allocator.h
@@ -310,11 +312,7 @@ files:
 - src/external/z80/sources/Z80.c
 - src/interrupt.c
 - src/interrupt.h
-- src/io.c.erb
-- src/io.h.erb
 - src/main.c
-- src/memory.c.erb
-- src/memory.h.erb
 homepage: https://github.com/jayvalentine/zemu
 licenses:
 - GPL-3.0