haxor 0.1.0

data/lib/haxor/token/base.rb

@@ -0,0 +1,7 @@
+module Haxor
+  module Token
+    class Base
+      attr_accessor :absolute_addr
+    end
+  end
+end

data/lib/haxor/token/cmd.rb

@@ -0,0 +1,9 @@
+module Haxor
+  module Token
+    class Cmd < Int64
+      def to_s
+        "Cmd -> 0x#{@data.to_s(16)}"
+      end
+    end
+  end
+end

data/lib/haxor/token/data.rb

@@ -0,0 +1,17 @@
+module Haxor
+  module Token
+    class Data < Base
+      def initialize(data)
+        @data = data
+      end
+
+      def size
+        @data.size
+      end
+
+      def to_s
+        @data.to_s
+      end
+    end
+  end
+end

data/lib/haxor/token/int64.rb

@@ -0,0 +1,17 @@
+module Haxor
+  module Token
+    class Int64 < Data
+      def to_bytecode
+        [@data].pack('q<')
+      end
+
+      def size
+        8
+      end
+
+      def to_s
+        "int64 -> #{@data}"
+      end
+    end
+  end
+end

data/lib/haxor/token/label.rb

@@ -0,0 +1,23 @@
+module Haxor
+  module Token
+    class Label < Base
+      attr_reader :label
+
+      def initialize(label)
+        @label = label
+      end
+
+      def to_bytecode
+        ''
+      end
+
+      def to_s
+        "Label -> #{@label}"
+      end
+
+      def size
+        0
+      end
+    end
+  end
+end

data/lib/haxor/token/pointer.rb

@@ -0,0 +1,13 @@
+module Haxor
+  module Token
+    class Pointer < Int64
+      attr_accessor :data
+      attr_reader :label
+
+      def initialize(label)
+        super(-1) # invalid pointer
+        @label = label
+      end
+    end
+  end
+end

data/lib/haxor/vm/core.rb

@@ -0,0 +1,53 @@
+module Haxor
+  module Vm
+    class Core
+      attr_reader :mem
+
+      def initialize
+        @subsystems = {}
+        register_subsystem :cpu, Cpu::Core.new
+        register_subsystem :mem, Mem.new(Consts::RESERVED_MEM)
+        register_subsystem :stack, Stack.new
+        register_subsystem :os, Os.new
+
+        subsystem(:cpu).labels.each do |_, label|
+          subsystem(:mem).add_label label.label, label.absolute_addr
+        end
+
+        @units = []
+        @opcodes = {}
+      end
+
+      def register_subsystem(id, object)
+        @subsystems[id] = object
+        object.vm = self
+      end
+
+      def subsystem(id)
+        @subsystems[id]
+      end
+
+      def execute
+        loop do
+          subsystem(:cpu).iterate
+        end
+      end
+
+      def load_program(filename)
+        exe = File.read(filename, encoding: 'ASCII-8BIT')
+
+        @hdr = Header.new
+        @hdr.parse! exe
+
+        fail if @hdr.version != Consts::VERSION
+
+        exe = exe[@hdr.size..-1] # cut off header
+        subsystem(:mem).replace_region Consts::RESERVED_MEM, exe
+        subsystem(:mem).write 'ip', @hdr.entry_point # instruction pointer
+        subsystem(:mem).enlarge @hdr.bss_size
+        subsystem(:mem).enlarge @hdr.stack_size
+        subsystem(:mem).write 'sp', subsystem(:mem).size
+      end
+    end
+  end
+end

data/lib/haxor/vm/cpu/core.rb

@@ -0,0 +1,129 @@
+module Haxor
+  module Vm
+    module Cpu
+      class Core < Subsystem
+        attr_reader :struct
+        attr_reader :labels
+
+        def initialize
+          @units = []
+          @opcodes = {}
+
+          register_unit Unit::Arithmetic.new
+          register_unit Unit::Jumps.new
+          register_unit Unit::Logical.new
+          register_unit Unit::Transfer.new
+          register_unit Unit::Various.new
+
+          build_struct
+        end
+
+        def bind_opcode(opcode, object, method)
+          fail "OpCode already defined - #{opcode}." if @opcodes.key? opcode
+          @opcodes[opcode] = {
+            object: object,
+            method: method
+          }
+        end
+
+        def iterate
+          opcode = subsystem(:mem).next_cell
+          cmd = opcode & Consts::OPCODE_CMD_MASK
+          subsystem(:mem).write 'op', opcode
+
+          fail "Call to not existing opcode #{cmd}." unless @opcodes.key? cmd
+          #        puts 'cmd = ' + cmd.to_s(16)
+          #        puts flg.to_s(16)
+          @opcodes[cmd][:object].send(@opcodes[cmd][:method])
+        end
+
+        def reserved_mem
+          1024
+        end
+
+        def register_unit(unit)
+          @units << unit
+          unit.vm = self
+          unit.register
+        end
+
+        def operand
+          flg = (subsystem(:mem).read 'op') & Consts::OPCODE_FLG_MASK
+          a = subsystem(:mem).next_cell
+          a = subsystem(:mem).read a if (flg & Consts::OPCODE_FLG_DA != 0)
+          a
+        end
+
+        def operands
+          flg = (subsystem(:mem).read 'op') & Consts::OPCODE_FLG_MASK
+
+          a = subsystem(:mem).next_cell
+          a = subsystem(:mem).read a if (flg & Consts::OPCODE_FLG_DA != 0)
+
+          b = subsystem(:mem).next_cell
+          b = subsystem(:mem).read b if (flg & Consts::OPCODE_FLG_DB != 0)
+
+          [a, b]
+        end
+
+        private
+
+        def build_struct
+          @struct = []
+
+          @struct << Token::Label.new('null')
+          @struct << Token::Int64.new(0)
+
+          @struct << Token::Label.new('registers')
+
+          # instruction pointer
+          @struct << Token::Label.new('ip')
+          @struct << Token::Int64.new(0)
+
+          # stack pointer
+          @struct << Token::Label.new('sp')
+          @struct << Token::Int64.new(0)
+
+          # base pointer
+          @struct << Token::Label.new('bp')
+          @struct << Token::Int64.new(0)
+
+          # arithmetic registry I
+          @struct << Token::Label.new('ar')
+          @struct << Token::Int64.new(0)
+
+          # arithmetic registry II
+          @struct << Token::Label.new('dr')
+          @struct << Token::Int64.new(0)
+
+          # flags registry
+          @struct << Token::Label.new('fr')
+          @struct << Token::Int64.new(0)
+
+          # currently processed opcode (with opcode flags)
+          @struct << Token::Label.new('op')
+          @struct << Token::Int64.new(0)
+
+          # system call
+          @struct << Token::Label.new('sc')
+          @struct << Token::Int64.new(0)
+
+          # general usage registers
+          (1..10).each do |i|
+            @struct << Token::Label.new(format('r%02d', i))
+            @struct << Token::Int64.new(0)
+          end
+
+          addr = 0
+          @labels = {}
+          @struct.each do |token|
+            token.absolute_addr = addr
+            addr += token.size
+
+            @labels[token.label] = token if token.is_a? Token::Label
+          end
+        end
+      end
+    end
+  end
+end

data/lib/haxor/vm/cpu/unit/arithmetic.rb

@@ -0,0 +1,92 @@
+module Haxor
+  module Vm
+    module Cpu
+    module Unit
+      class Arithmetic < Base
+        #            0x00 (not used)
+        OP_ADD     = 0x01 # add a, b
+        OP_SUB     = 0x02 # sub a, b
+        OP_DIV     = 0x03 # div a
+        OP_MUL     = 0x04 # mul a
+        OP_INC     = 0x05 # inc a
+        OP_DEC     = 0x06 # dec a
+        OP_CMP     = 0x07 # cmp a, b
+        #            0x1f
+
+        def register
+          bind_opcode OP_ADD, :op_add
+          bind_opcode OP_SUB, :op_sub
+          bind_opcode OP_DIV, :op_div
+          bind_opcode OP_MUL, :op_mul
+          bind_opcode OP_INC, :op_inc
+          bind_opcode OP_DEC, :op_dec
+          bind_opcode OP_CMP, :op_cmp
+        end
+
+        def op_add
+          a, b = operands
+          c = @vm.subsystem(:mem).read(a) + @vm.subsystem(:mem).read(b)
+          @vm.subsystem(:mem).write a, c
+        end
+
+        def op_sub
+          a, b = operands
+          c = @vm.subsystem(:mem).read(a) - @vm.subsystem(:mem).read(b)
+          @vm.subsystem(:mem).write a, c
+        end
+
+        def op_div
+          a = operand
+          av = @vm.subsystem(:mem).read a
+          arv = @vm.subsystem(:mem).read 'ar'
+          @vm.subsystem(:mem).write 'ar', (arv / av)
+          @vm.subsystem(:mem).write 'dr', (arv % av)
+        end
+
+        def op_mul
+          a = operand
+          av = @vm.subsystem(:mem).read a
+          arv = @vm.subsystem(:mem).read 'ar'
+          @vm.subsystem(:mem).write 'ar', (arv * av)
+        end
+
+        def op_inc
+          a = operand
+          av = @vm.subsystem(:mem).read a
+          @vm.subsystem(:mem).write a, (av + 1)
+        end
+
+        def op_dec
+          a = operand
+          av = @vm.subsystem(:mem).read a
+          @vm.subsystem(:mem).write a, (av - 1)
+        end
+
+        def op_cmp
+          a, b = operands
+          av = @vm.subsystem(:mem).read a
+          bv = @vm.subsystem(:mem).read b
+          v = av - bv
+          fr_set Consts::FR_ZERO, (v == 0)
+          fr_set Consts::FR_SIGN, v < 0
+        end
+
+        def fr_set(b, enable)
+          flags = fetch_cell 'fr'
+          if enable
+            flags |= b
+          else
+            flags &= ~b
+          end
+          replace_cell 'fr', flags
+        end
+
+        def fr_if(b)
+          flags = fetch_cell 'fr'
+          (flags & b) > 0
+        end
+      end
+    end
+    end
+  end
+end

data/lib/haxor/vm/cpu/unit/base.rb

@@ -0,0 +1,46 @@
+module Haxor
+  module Vm
+    module Cpu
+    module Unit
+      class Base
+        attr_accessor :vm
+
+        def register
+          fail 'this method must be implemented.'
+        end
+
+        def bind_opcode(opcode, method)
+          @vm.bind_opcode opcode, self, method
+        end
+
+        # TODO: BC
+        def next_cell
+          @vm.subsystem(:mem).next_word
+        end
+
+        # TODO: BC
+        def fetch_cell(addr)
+          @vm.subsystem(:mem).read addr
+        end
+
+        def dereference(addr)
+          @vm.subsystem(:mem).read addr
+        end
+
+        # TODO: BC
+        def replace_cell(addr, value)
+          @vm.subsystem(:mem).write addr, value
+        end
+
+        def operand
+          @vm.operand
+        end
+
+        def operands
+          @vm.operands
+        end
+      end
+    end
+    end
+  end
+end

data/lib/haxor/vm/cpu/unit/jumps.rb

@@ -0,0 +1,123 @@
+module Haxor
+  module Vm
+    module Cpu
+    module Unit
+      class Jumps < Base
+        #         0x20
+        OP_CALL = 0x20 # call a
+        OP_JMP  = 0x21 # jmp a
+        OP_JE   = 0x22 # je a
+        OP_JG   = 0x23 # jg a
+        OP_JGE  = 0x24 # jge a
+        OP_JL   = 0x25 # jl a
+        OP_JLE  = 0x26 # jle a
+        OP_JNE  = 0x27 # jne a
+        OP_JNG  = 0x28 # jng a
+        OP_JNGE = 0x29 # jnge a
+        OP_JNL  = 0x2a # jnl a
+        OP_JNLE = 0x2b # jnle a
+        OP_RET  = 0x2c # ret
+        OP_IRET = 0x2d # iret
+        #         0x3f
+
+        def register
+          bind_opcode OP_CALL,   :op_call
+          bind_opcode OP_JMP,    :op_jmp
+          bind_opcode OP_JE,     :op_je
+          bind_opcode OP_JG,     :op_jg
+          bind_opcode OP_JGE,    :op_jge
+          bind_opcode OP_JL,     :op_jl
+          bind_opcode OP_JLE,    :op_jle
+          bind_opcode OP_JNE,    :op_jne
+          bind_opcode OP_JNG,    :op_jng
+          bind_opcode OP_JNGE,   :op_jnge
+          bind_opcode OP_JNL,    :op_jnl
+          bind_opcode OP_JNLE,   :op_jnle
+          bind_opcode OP_RET,    :op_ret
+          bind_opcode OP_IRET,   :op_iret
+        end
+
+        def fr_if(b)
+          flags = fetch_cell 'fr'
+          (flags & b) > 0
+        end
+
+        def op_call
+          a = operand
+          @vm.subsystem(:stack).push 'ip'
+          jmp a
+        end
+
+        def op_jmp
+          a = operand
+          jmp a
+        end
+
+        def op_je
+          a = operand
+          jmp a if fr_if Consts::FR_ZERO
+        end
+
+        def op_jg
+          a = operand
+          jmp a if !fr_if(Consts::FR_ZERO) && !fr_if(Consts::FR_SIGN)
+        end
+
+        def op_jge
+          a = operand
+          jmp a if !fr_if(Consts::FR_SIGN) || fr_if(Consts::FR_ZERO)
+        end
+
+        def op_jl
+          a = operand
+          jmp a if !fr_if(Consts::FR_ZERO) && fr_if(Consts::FR_SIGN)
+        end
+
+        def op_jle
+          a = operand
+          jmp a if fr_if(Consts::FR_SIGN) || fr_if(Consts::FR_ZERO)
+        end
+
+        def op_jne
+          a = operand
+          jmp a unless fr_if Consts::FR_ZERO
+        end
+
+        def op_jng
+          a = operand
+          jmp a unless !fr_if(Consts::FR_ZERO) && !fr_if(Consts::FR_SIGN)
+        end
+
+        def op_jnge
+          a = operand
+          jmp a unless !fr_if(Consts::FR_SIGN) || fr_if(Consts::FR_ZERO)
+        end
+
+        def op_jnl
+          a = operand
+          jmp a unless !fr_if(Consts::FR_ZERO) && fr_if(Consts::FR_SIGN)
+        end
+
+        def op_jnle
+          a = operand
+          jmp a unless fr_if(Consts::FR_SIGN) || fr_if(Consts::FR_ZERO)
+        end
+
+        def op_ret
+          @vm.subsystem(:stack).pop 'ip'
+        end
+
+        def op_iret
+          @vm.subsystem(:stack).pop 'ip'
+        end
+
+        private
+
+        def jmp(addr)
+          @vm.subsystem(:mem).write 'ip', addr
+        end
+      end
+    end
+  end
+end
+end