zemu 0.4.1 → 1.0.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

@@ -60,7 +60,15 @@ module Zemu
             UNDEFINED = -1
         end
 
+        
+
         def initialize(configuration)
+            @devices = configuration.devices
+
+            # Methods defined by bus devices that we make
+            # accessible to the user.
+            @device_methods = []
+
             @clock = configuration.clock_speed
             @serial_delay = configuration.serial_delay
 
@@ -69,6 +77,70 @@ 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
+                    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
+                    end
+                end
+
+                r
+            end
+
+            # IO read handler.
+            @io_clock = Proc.new do
+                @devices.each do |d|
+                    d.clock()
+                end
+
+                bus_state = 0
+
+                if @devices.any? { |d| d.nmi? }
+                    bus_state |= 1
+                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)
 
@@ -77,6 +149,18 @@ module Zemu
             @breakpoints = {}
         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.
         def clock_speed
             return @clock
@@ -253,6 +337,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, [:void], :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
 
@@ -271,15 +370,25 @@ 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"])
+                    @device_methods << f["name"].to_sym
                 end
             end
 
             return wrapper
         end
 
+        # Redirects calls to I/O FFI functions.
+        def method_missing(method, *args)
+            if @device_methods.include? method
+                return @wrapper.send(method)
+            end
+
+            super
+        end
+
         private :make_wrapper
     end
 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.
@@ -185,6 +197,9 @@ module Zemu
                 cycles_left -= cycles_done
                 actual_cycles += cycles_done
 
+                @trace << r16("PC")
+                @trace = @trace[1..] if @trace.size > 200
+
                 # Get time after execution.
                 ending = Time.now
 
@@ -199,6 +214,11 @@ module Zemu
                     sleep(padding) unless padding < 0
                 end
 
+                if (@instance.memory(0x200) != 0xf3)
+                    log "Buffer overflow at #{r16("PC")}"
+                    break
+                end
+
                 # Have we hit a breakpoint or HALT instruction?
                 if @instance.break?
                     log "Hit breakpoint at #{r16("PC")}."
@@ -258,7 +278,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

@@ -62,10 +62,12 @@ module Zemu
     SRC = File.join(__dir__, "..", "src")
 
     # Build and start an emulator according to the given configuration.
+    # Returns the emulator instance.
     #
     # @param [Zemu::Config] configuration The configuration for which an emulator will be generated.
-    def Zemu::start(configuration)
-        build(configuration)
+    # @param user_defines Any user-defined preprocessor macros.
+    def Zemu::start(configuration, user_defines={})
+        build(configuration, user_defines)
 
         return Instance.new(configuration)
     end
@@ -81,11 +83,11 @@ module Zemu
     end
 
     # Builds a library according to the given configuration.
+    # Returns true if the build is a success, false (build failed) or nil (compiler not found) otherwise.
     #
     # @param [Zemu::Config] configuration The configuration for which an emulator will be generated.
-    #
-    # @returns true if the build is a success, false (build failed) or nil (compiler not found) otherwise.
-    def Zemu::build(configuration)
+    # @param user_defines Any user-defined preprocessor macros.
+    def Zemu::build(configuration, user_defines={})
         # Create the output directory unless it already exists.
         unless Dir.exist? configuration.output_directory
             Dir.mkdir configuration.output_directory
@@ -109,13 +111,15 @@ 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,
             "CPU_Z80_USE_LOCAL_HEADER" => 1
         }
 
+        defines.merge! user_defines
+
         defines_str = defines.map { |d, v| "-D#{d}=#{v}" }.join(" ")
 
         includes = [
@@ -139,32 +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)
-    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"))
-
-        autogen = File.join(configuration.output_directory, "autogen_#{configuration.name}")
-
-        unless Dir.exist? autogen
-            Dir.mkdir autogen
-        end
-
-        File.write(File.join(autogen, "memory.h"),
-                   header_template.result(configuration.get_binding))
-
-        File.write(File.join(autogen, "memory.c"),
-                   source_template.result(configuration.get_binding))
+        generate_bus(configuration)
     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"))
+    # 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}")
 
@@ -172,10 +157,10 @@ module Zemu
             Dir.mkdir autogen
         end
 
-        File.write(File.join(autogen, "io.h"),
+        File.write(File.join(autogen, "bus.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,99 @@
+#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;
+
+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)
+{
+    zuint32 address_32 = address;
+    return mem_read_handler(address_32);
+}
+
+void zemu_memory_write(void * context, zuint16 address, zuint8 value)
+{
+    zuint32 address_32 = address;
+    mem_write_handler(address_32, value);
+}
+
+zuint8 zemu_memory_peek(zuint16 address)
+{
+    zuint32 address_32 = address;
+    return mem_read_handler(address_32);
+}
+
+void zemu_memory_poke(zuint16 address, zuint8 value)
+{
+    zuint32 address_32 = address;
+    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)
+{
+    zuint8 bus_state = io_clock_handler();
+
+    if (bus_state & 0x01) zemu_io_nmi(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(void);
+
+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);
+
+#endif

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.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Jay Valentine
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-11-18 00:00:00.000000000 Z
+date: 2021-12-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

data/src/io.c.erb

@@ -1,52 +0,0 @@
-#include "io.h"
-
-<% io.each do |device| %>
-<%= 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.
-     * We cannot assume that the top half is valid.
-     */
-    port &= 0x00FF;
-
-<% io.each do |device| %>
-<%= device.read %>
-<% end %>
-    return 0;
-}
-
-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.each do |device| %>
-<%= device.write %>
-<% end %>
-}
-
-void zemu_io_clock(Z80 * instance)
-{
-<% io.each do |device| %>
-<%= device.clock %>
-<% end %>
-}

data/src/io.h.erb

@@ -1,25 +0,0 @@
-#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;
-
-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);
-
-#endif