ucisc 0.1.3 → 0.1.4

data/examples/hello_world.ucisc

@@ -1,96 +1,87 @@
-# A recursive factorial algorithm
-# Inspired by the SubX example near the bottom of this post:
-# http://akkartik.name/post/mu-2019-1
-#
-# The goal is to compare the implementation of the uCISC ISA to x86
-# as well as roughly see how things line up with SubX and look for
-# the coming MuCISC goals
+# Print hello world to the console
 #
 # To run:
-#   $ exe/ucisc examples/factorial.ucisc
+#   $ exe/ucisc examples/hello_world.ucisc core/stdlib.ucisc
 #
-# Type 'break' when you hit the breakpoint, then `load(register(1))`
-# to view the result on the stack
+# The stack should be empty when complete. It prints the following:
 #
-# More instructions on the compiler and debugger are in the README.md
-# Or use GitHub https://github.com/grokthis/ucisc-ruby#usage
+# Hello, world! uCISC is here!
 
-# Setup some simple syntax sugar for easy reference to stack and pc
-$stack as 1.mem
+################
+# Syntax Setup #
+################
 &pc as 0.reg
+&banking as 4.reg
 
-# Simple conditional syntax sugar
+# Conditionals
 $zero? as 0.eff
 $not_zero? as 1.eff
 
-Entry:
-  # Init stack pointer
-  copy 0.imm &stack
-
-  # Functions calls reserve space on the stack (the stack size number in brackets)
-  # Then they push the return address, followed by the args. The called function
-  # is expected to remove the return address and args from the stack before returning
-  $stack <= print_string(31.imm, hello.imm)
+# Compute Ops
+$shift_left as 0x5.op
+$shift_right as 0x6.op
+$high_byte as 0x8.op # zero least significant byte
+$add as 0xA.op
 
-  # halt
-  copy &pc &pc
+################
+#  Code Entry  #
+################
+&stack as copy 0.imm 1.reg
 
-hello:
+$stack[1] <= init_device(16.imm)
+$&device_control = $stack
 
-# "\nHello, world! uCISC is here!\n\n" in hex
-% 0A48 656C 6C6f 2C20 776F 726C 6421 2075 4349 5343 2069 7320 6865 7265 210A 0A00
+$stack <= print_string($&device_control, hello.imm)
 
-term_device:
-% 0100
+# pop device control
+copy &&device_control 1.imm &stack
 
-print_string: # (len, *string)
-  # reference term control
-  &term = copy &pc term_device.disp 2.reg
-  copy $term &term
-  # Save to stack for quick restore later
-  copy &term $stack push
+# halt
+copy &pc &pc
 
-  # Bank regions 0x0000 and 0x1000
-  copy 3.imm 4.reg
-  # reference term page
-  compute 0x8.op/zero LSB/ $term 1.imm &term
+################
+# Main Section #
+################
+hello:
+% "\nHello, world! uCISC is here!\n\n"
 
-  # Bank region 0x1000
-  copy 2.imm 4.reg
+print_string: # (&device_control, &string)
+  $&string, $&device_control, $&return = $stack
 
-  &str = copy $stack 1.imm 3.reg
-  # Move length to top of stack
-  copy $stack 2.imm $stack push
+  &device_control = copy $&device_control 3.reg
+  $&device_bank = $device_control 1.imm
 
-  # Len is in bytes, add 1 and divide by 2 to get word len
-  compute 0xA.op/add/ 1.imm $stack
-  compute 0x6.op/shift >>/ 1.imm $stack
+  #bank control segment
+  copy 1.imm &banking
+  &stdout as compute $high_byte $&device_bank 3.reg
+  #bank stdout buffer segment
+  copy 2.imm &banking
 
-  # Loop over string, copy to $term
-  {
-    copy &pc break.disp &pc $zero?
+  &string as copy $&string 2.reg
+  $string.len, $string.data = $string
 
-    {
-      copy $str $term
-      compute 0xA.op/add/ 1.imm &str
-      compute 0xA.op/add/ 1.imm &term
+  # Length is in bytes, add 1 and divide by 2 to get word len
+  $word_len = copy $string.len $stack push
+  compute $add 1.imm $word_len
+  compute $shift_right 1.imm $word_len
 
-      compute 0xB.op/subtract/ 1.imm $stack
+  $stack <= mem_copy(&string.data, &stdout, $word_len)
 
-      copy &pc loop.disp &pc $not_zero?
-    }
-  }
+  &string as copy $&string 2.reg
+  $string.len = $string
+  &device_control = copy $&device_control 3.reg
+  $stdout.read_count as $device_control 6.imm
+  # we need to put $string.len on the stack so banking doesn't make it invisible
+  $len = copy $string.len $stack push
 
-  # restore terminal control pointer
-  copy $stack 1.imm &term
-  # Bank regions 0x0000 and 0x1000
-  copy 3.imm 4.reg
+  #bank control segment
+  copy 1.imm &banking
   # write length to terminal control
-  copy $stack 3.imm $term 5.imm
+  copy $len $stdout.read_count
   # Unbank all regions
-  copy 0.imm 4.reg
-
-  copy &stack 4.imm &stack
+  copy 0.imm &banking
 
   # Jump return
-  copy $stack &pc pop
+  copy &&return &stack
+  copy $&return &pc pop
+

data/examples/paint_image.ucisc

@@ -0,0 +1,261 @@
+# Draws an image on the screen at 16, 16 (from the top left)
+# Basic algorithm:
+# *Setup*
+#  1. The image data is part of the compiled output, but it
+#     must be paged in. Processors only get the first page
+#     of a task by default, so programs need to load themselves
+#     into local memory first.
+#  2. Paint the image
+#
+# *Painting*
+# For each line in the image:
+#  1. Calculate page offset and count for a image raster line
+#  2. Page in the relevant pages from main memory. Note, this
+#     isn't strictly necessary for this example as no other
+#     code is drawing to the screen, but it's a moral victory.
+#  3. Copy the memory from the image data region to the proper
+#     location in the paged memory.
+#  4. Page the memory back to main memory in the proper location.
+#     Since the video memory is mapped to the main memory at a
+#     specific location, this causes the line to draw immediately.
+#
+# The program halts when done and the CPU will idle.
+#
+# Notes:
+#  * Double buffering is not implemented and the necessary hardware
+#    is not emulated. So, the screen will "tear" if you don't draw
+#    fast enough.
+#  * In practice, the CPU can definitely outrun the paging mechanisms.
+#    I got some nice partial images when I turned off access blocking
+#    to pages that were in the process of paging.
+#  * This page in/page out mechanism kills at least half your available
+#    performance. It would be better to load multiple lines worth of
+#    pages at once, draw on them and page them out. That's a harder
+#    algorithm but in theory could preserve most of your performance.
+#    This is just a proof of concept so I didn't do that.
+#
+# Conventions:
+# 
+# I put psuedo code in the comments for each instruction. Some notes
+# about reading them and other things to know:
+# 
+#  * `var name = value` - var is created on the stack
+# 
+#  * Registers are generally treated as pointers
+# 
+#  * I tried to use C pointer semantics for comments. It's not perfect
+#  because some of the dereferencing is a bit different here and it's not
+#  checked by a compiler or running code so take them with a grain of salt.
+# 
+#  * The one exception is occaisionally they get loaded with an increment
+#  value. Sometimes you just need to add one real fast.
+# 
+#  * You can generally easily count stack offsets by counting 1.push args
+# 
+#  * Don't forget to add offsets for any vars returned by functions on
+#  the stack. I commented function return values for easy reference.
+# 
+#  * r1 is the stack, don't use it for anything else.
+# 
+#  * r2, r3 are not preserved by function calls, any one can do anything
+#  with them. Assume they are garbage after a function call.
+# 
+#  * One variable needed on every loop iteration is always on the top of
+#  the stack for easy access.
+# 
+#  * I found calculating before the loop to be pretty efficient. A quick
+#  subtract will set the zero flag and you can jump over the break easily.
+# 
+#  * The order is heavily influenced by the limits of function call
+#  immediate values. Notice the _page hack right off the bat.
+# 
+#  * I'll be updating function calls to handle this more gracefully.
+#
+#  * `calculate_page_offset` uses 32-bit math. Check it out.
+#
+# To run:
+#   $ exe/ucisc examples/image.ucisc
+#
+# Then: view the image. It works!!
+#
+# Instructions on the compiler and debugger are in the README.md
+# Or use GitHub https://github.com/grokthis/ucisc-ruby#usage
+
+################
+# Syntax Setup #
+################
+&stack as 1.reg
+&pc as 0.reg
+&banking as 4.reg
+
+# Conditionals
+$zero? as 0.eff
+$not_zero? as 1.eff
+$negative? as 2.eff
+
+# Compute Ops
+$invert as 0x0.op
+$and as 0x1.op
+$or as 0x2.op
+$xor as 0x3.op
+$increment as 0x4.op
+$shift_left as 0x5.op
+$shift_right as 0x6.op
+$swap_bytes as 0x7.op
+$high_byte as 0x8.op # zero least significant byte
+$low_byte as 0x9.op # zero most significant byte
+$add as 0xA.op
+$subtract as 0xB.op
+$multiply as 0xC.op
+$divide as 0xD.op
+$add_overflow as 0xE.op
+$mask_to_overflow as 0xF.op
+
+################
+#  Code Entry  #
+################
+Entry:
+$&return = $stack
+
+$stack[1] <= stdlib_init_device(17.imm)
+$&device_control = $stack
+
+$y = copy 10.imm $stack push
+$x = copy 0.imm $stack push
+{
+  $stack <= paint_image(&pc image.disp, $x, $y, $&device_control)
+  $stack <= paint_image(&pc blank_left.disp, $x, $y, $&device_control)
+  
+  compute $add 1.imm $x
+  compute $low_byte $x $x
+
+  copy &pc loop.disp &pc
+}
+
+# Image:struct
+# pixels:*word[]
+# width:int
+# height:int
+image:
+% image.data.imm
+% 0040 # width: 64
+% 0030 # height: 48
+
+blank_left:
+% 2000
+% 0001 # width: 1
+% 0030 # height: 48
+
+stdlib_init_device:
+  copy &pc init_device.disp &pc
+stdlib_mem_copy:
+  copy &pc mem_copy.disp &pc
+
+# $stack <= paint_image($&image, $x, $y, $&screen_device)
+paint_image:
+  $&screen_device, $y, $x, $&image, $&return = $stack
+
+  $screen_device as 3.mem
+  copy $&screen_device &screen_device
+  $screen_device.w, $screen_device.h = $screen_device 6.imm
+
+  &image = copy $&image 2.reg
+  $image.data, $image.width, $image.height as $image
+
+  $c_row = copy 0.imm $stack push
+  $c_y = copy $y $stack push
+  $end_y = copy $y $stack push
+  compute $add $image.height $end_y
+
+  # Cap $end_y to screen height
+  copy 1.imm &banking
+  $max = copy $screen_device.h $stack push
+  $diff = compute $subtract $end_y $max
+  compute $multiply -1.imm $diff
+  { # if end_y > screen.height
+    copy &pc break.disp &pc $negative?
+
+    copy $screen_device.h $end_y # Cap at screen height
+  }
+  copy &end_y &stack
+  copy 0.imm &banking
+
+  {
+    $remaining = compute 0xB.op $c_y $end_y push
+    copy &pc break.disp &pc $negative?
+    copy &pc break.disp &pc $zero?
+
+    { # while c_y < end_y
+      $stack <= paint_line($x, $c_y, $c_row, &image, &screen_device)
+      # These can get destroyed by called methods
+      copy $&image &image
+      copy $&screen_device &screen_device
+
+      # Increment row and y vars
+      $tmp = copy $c_row $stack push
+      $tmp = compute $add 1.imm $tmp
+      copy $tmp $c_row
+      $tmp = copy $c_y $stack push
+      compute $add 1.imm $tmp
+      copy $tmp $c_y
+
+      copy &end_y &stack
+
+      $remaining = compute 0xB.op $c_y $end_y push
+      copy &pc loop.disp &pc $not_zero?
+    }
+  }
+
+  copy &&return &stack # pop all args
+  copy $&return &pc pop
+
+stdlib_mem_copy2:
+  copy &pc stdlib_mem_copy.disp &pc
+
+# $stack <= paint_line($x, $y, $image_row, $&image, $&screen_device)
+paint_line:
+  $&screen_device, $&image, $image_row, $y, $x, $&return = $stack
+
+  &screen_device = copy $&screen_device 3.reg
+  $screen_device.bank = $screen_device 1.imm
+  $screen_device.block = $screen_device 3.imm
+  $screen_device.w, $screen_device.h = $screen_device 6.imm
+
+  &image as copy $&image 2.reg
+  $image.&data, $image.width, $image.height = $image
+
+  # 1. figure out which block we need
+  # screen row = y_offset + image_row
+  $screen_row = copy $y $stack push
+
+  $&source = copy $image_row $stack push
+  compute $multiply $image.width $&source
+  compute $add $image.&data $&source
+
+  copy 1.imm &banking
+  $row_offset = copy $screen_device.w $stack push
+  compute $multiply $screen_row $row_offset
+
+  $word_offset = copy $x $stack push
+  compute $add $row_offset $word_offset
+
+  $word_block_offset = compute $low_byte $word_offset $stack push
+  $&target = copy $screen_device.bank $stack push
+  compute $high_byte $&target $&target
+  compute $or $word_block_offset $&target
+
+  $block = copy $word_offset $stack push
+  compute $high_byte $block $block
+  compute $swap_bytes $block $block
+  copy $block $screen_device.block
+  copy 2.imm &banking
+
+  #$stack[1] <= banked_mem_copy($&source, $&target, $image.width, &screen_device)
+  $stack <= stdlib_mem_copy2($&source, $&target, $image.width)
+  #$copied = $stack
+
+  copy 0.imm &banking
+
+  copy &&return &stack
+  copy $&return &pc pop
+

data/exe/png_to_hex

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "chunky_png"
+require "byebug"
+
+if ARGV.size < 2
+  puts "Usage:"
+  puts "  png_to_hex <input_file> <output_file>"
+  exit(0)
+end
+
+image = ChunkyPNG::Image.from_file(ARGV.first)
+rows = []
+hex = []
+image.pixels.each do |pixel|
+  rgba = "%08X" % pixel
+  pixel = pixel >> 8
+  b = (((pixel & 0xFF) + 8) & 0xF0) >> 4
+  pixel = pixel >> 8
+  g = (((pixel & 0xFF) + 8) & 0xF0) >> 4
+  pixel = pixel >> 8
+  r = (((pixel & 0xFF) + 8) & 0xF0) >> 4
+
+  color = (r << 8 | g << 4 | b )
+  hex << "%04X" % color
+
+  if hex.size == 16
+    rows << "% #{hex.join(" ")}"
+    hex = []
+  end
+end
+
+rows << "% #{hex.join(" ")}" if hex.size > 0
+hex = []
+
+File.open(ARGV.last, 'w') { |file| file.write(rows.join("\n")) }
+