haxor 0.3.0 → 0.4.0

data/lib/haxor/consts.rb

@@ -1,7 +1,7 @@
 module Haxor
   class Consts
     MAJOR = 0
-    MINOR = 3
+    MINOR = 4
     PATCH = 0
     GEM_VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
     VERSION = (MAJOR << 16) | (MINOR << 8) | PATCH
@@ -11,21 +11,8 @@ module Haxor
     WORD_SIZE = 8 # 64bit
     WORD_UNPACK = 'q<'
 
-    RESERVED_MEM = 2048 # 1024 for CPU, 1024 for IVT
-    IVT_ADDR     = 1024
-
-    # OpCode
-    OPCODE_CMD_MASK = 0x0000_0000_0000_00ff
-    OPCODE_FLG_MASK = 0xffff_ffff_ffff_ff00 # << 8
-    OPCODE_FLG_OFFSET = 8
-    # 8 bits of flag - 1st operand
-    # 8 bits of flag - 2nd operand
-
-    OPERAND_FLAGS = 8 # how many bits per operand
-    OPERAND_DEREFERENCE = (1 << 0) # Dereference operand (aka *operand)
-
-    # Flags Registry Flags
-    FR_ZERO    = 1 << 0 # a-b == 0
-    FR_SIGN    = 1 << 1 # a-b < 0
+    IVT_MEM      = 1024
+    IVT_ADDR     = 0
+    RESERVED_MEM = IVT_MEM
   end
 end

data/lib/haxor/linker.rb

@@ -8,7 +8,7 @@ module Haxor
       @cpu = Vm::Cpu::Core.new
       @units = []
       @tokens = []
-      @labels = @cpu.labels.clone
+      @labels = {}
       @stack = 4096
     end
 
@@ -56,9 +56,17 @@ module Haxor
     end
 
     def unwind_pointers
-      walk_tokens(Token::Pointer) do |token|
-        fail "Label not found: #{token.label}." unless @labels.key? token.label
-        token.data = @labels[token.label].absolute_addr
+      walk_tokens(Token::Cmd) do |token|
+        next unless token.imm.is_a? String
+        fail "Label not found: #{token.imm}." unless @labels.key? token.imm
+
+        token.imm = @labels[token.imm].absolute_addr
+
+        if token.opts.include? :rel_imm
+          token.imm -= token.absolute_addr + Consts::WORD_SIZE
+        end
+
+        token.imm /= Consts::WORD_SIZE if token.opts.include? :x8
       end
     end
 

data/lib/haxor/token/cmd.rb

@@ -1,8 +1,35 @@
 module Haxor
   module Token
-    class Cmd < Int64
+    class Cmd < Base
+      attr_accessor :cmd
+      attr_accessor :flags
+      attr_accessor :reg1
+      attr_accessor :reg2
+      attr_accessor :reg3
+      attr_accessor :imm
+      attr_accessor :opts
+
+      def initialize
+        @cmd   = 0
+        @flags = 0
+        @reg1  = 0
+        @reg2  = 0
+        @reg3  = 0
+        @imm   = 0
+        @opts  = []
+      end
+
+      def size
+        Consts::WORD_SIZE
+      end
+
+      def to_bytecode
+        data = Utils.encode_opcode @cmd, @flags, @reg1, @reg2, @reg3, @imm
+        [data].pack Consts::WORD_UNPACK
+      end
+
       def to_s
-        "Cmd -> 0x#{@data.to_s(16)}"
+        "CMD code:[0x#{@cmd.to_s(16)}], flags:[#{@flags.to_s(2)}], regs:[#{@reg1}, #{@reg2}, #{@reg3}], imm:[#{@imm}], opts:#{@opts}"
       end
     end
   end

data/lib/haxor/utils.rb

@@ -0,0 +1,24 @@
+module Haxor
+  module Utils
+    def self.encode_opcode(cmd = 0, flags = 0, reg1 = 0, reg2 = 0, reg3 = 0, imm = 0)
+      result = cmd
+      result |= flags << 7
+      result |= reg1 << 9
+      result |= reg2 << 15
+      result |= reg3 << 21
+      result |= imm << 27
+      result
+    end
+
+    def self.decode_opcode(opcode)
+      r = OpenStruct.new
+      r.cmd   = opcode & 0x7f
+      r.flags = (opcode >> 7) & 0x03
+      r.reg1  = (opcode >> 9) & 0x3f
+      r.reg2  = (opcode >> 15) & 0x3f
+      r.reg3  = (opcode >> 21) & 0x3f
+      r.imm   = (opcode >> 27)
+      r
+    end
+  end
+end

data/lib/haxor/vm/core.rb

@@ -9,12 +9,7 @@ module Haxor
         register_subsystem :mem, Mem.new(Consts::RESERVED_MEM)
         register_subsystem :stack, Stack.new
         register_subsystem :os, Os.new
-        register_subsystem :registers, Registers.new
-
-        subsystem(:cpu).labels.each do |_, label|
-          subsystem(:mem).add_label label.label, label.absolute_addr
-          subsystem(:registers).add_register label.label, label.absolute_addr
-        end
+#        register_subsystem :registers, Registers.new
 
         @units = []
         @opcodes = {}
@@ -41,14 +36,16 @@ module Haxor
         @hdr = Header.new
         @hdr.parse! exe
 
-        fail if @hdr.version != Consts::VERSION
+        if @hdr.version != Consts::VERSION
+          fail 'Program is compiled for different version of Haxor VM Machine'
+        end
 
         exe = exe[@hdr.size..-1] # cut off header
         subsystem(:mem).replace_region Consts::RESERVED_MEM, exe
-        subsystem(:registers).write 'ip', @hdr.entry_point # instruction pointer
+        subsystem(:cpu).ip = @hdr.entry_point # instruction pointer
         subsystem(:mem).enlarge @hdr.bss_size
         subsystem(:mem).enlarge @hdr.stack_size
-        subsystem(:registers).write 'sp', subsystem(:mem).size
+        subsystem(:cpu).reg Vm::Cpu::Core::REG_STACK, subsystem(:mem).size
       end
     end
   end

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

@@ -2,126 +2,257 @@ module Haxor
   module Vm
     module Cpu
       class Core < Subsystem
-        attr_reader :struct
-        attr_reader :labels
+        attr_accessor :ip
+
+        # Misc
+        OP_NOP     = 0x00
+        OP_EXITI   = 0x01
+        OP_SYSCALL = 0x02
+
+        # Arithmetic
+        OP_ADD     = 0x10
+        OP_ADDI    = 0x11
+        OP_SUB     = 0x12
+        OP_MULT    = 0x13
+        OP_DIV     = 0x14
+        OP_MOD     = 0x15
+
+        # Data transfer
+        OP_LW      = 0x20
+        OP_SW      = 0x21
+        OP_LUI     = 0x22
+
+        # Logical
+        OP_AND     = 0x30
+        OP_ANDI    = 0x31
+        OP_OR      = 0x32
+        OP_ORI     = 0x33
+        OP_XOR     = 0x34
+        OP_NOR     = 0x35
+        OP_SLT     = 0x36
+        OP_SLTI    = 0x37
+
+        # Bitwise shift
+        OP_SLLI    = 0x40
+        OP_SRLI    = 0x41
+        OP_SLL     = 0x42
+        OP_SRL     = 0x43
+
+        # Branch/Jumps
+        OP_BEQ     = 0x50
+        OP_BEQL    = 0x51
+        OP_BNE     = 0x52
+        OP_BNEL    = 0x53
+        OP_J       = 0x54
+        OP_JR      = 0x55
+        OP_JAL     = 0x56
+
+        REG_ZERO    = 0
+        REG_STACK   = 61
+        REG_RETURN  = 62
+        REG_SYSCALL = 63
 
         def initialize
+          @registers = Array.new(64, 0)
           @units = []
           @opcodes = {}
+          init_opcodes
+        end
 
-          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
+        def init_opcodes
+          bind_opcode OP_NOP, :op_nop
+          bind_opcode OP_ADD, :op_add
+          bind_opcode OP_ADDI, :op_addi
+          bind_opcode OP_SUB, :op_sub
+          bind_opcode OP_MULT, :op_mult
+          bind_opcode OP_DIV, :op_div
+          bind_opcode OP_MOD, :op_mod
+          bind_opcode OP_LW, :op_lw
+          bind_opcode OP_SW, :op_sw
+          bind_opcode OP_LUI, :op_lui
+          bind_opcode OP_AND, :op_and
+          bind_opcode OP_ANDI, :op_andi
+          bind_opcode OP_OR, :op_or
+          bind_opcode OP_ORI, :op_ori
+          bind_opcode OP_XOR, :op_xor
+          bind_opcode OP_NOR, :op_nor
+          bind_opcode OP_SLT, :op_slt
+          bind_opcode OP_SLTI, :op_slti
+          bind_opcode OP_SLLI, :op_slli
+          bind_opcode OP_SRLI, :op_srli
+          bind_opcode OP_SLL, :op_sll
+          bind_opcode OP_SRL, :op_srl
+          bind_opcode OP_BEQ, :op_beq
+          bind_opcode OP_BEQL, :op_beql
+          bind_opcode OP_BNE, :op_bne
+          bind_opcode OP_BNEL, :op_bnel
+          bind_opcode OP_J, :op_j
+          bind_opcode OP_JR, :op_jr
+          bind_opcode OP_JAL, :op_jal
+          bind_opcode OP_EXITI, :op_exiti
+          bind_opcode OP_SYSCALL, :op_syscall
+        end
 
-          build_struct
+        def op_nop(info)
         end
 
-        def bind_opcode(opcode, object, method)
-          fail "OpCode already defined - #{opcode}." if @opcodes.key? opcode
-          @opcodes[opcode] = {
-            object: object,
-            method: method
-          }
+        def op_add(info)
+          reg info.reg1, reg(info.reg2) + reg(info.reg3)
         end
 
-        def iterate
-          opcode = subsystem(:mem).next_cell
-          cmd = opcode & Consts::OPCODE_CMD_MASK
-          subsystem(:mem).write 'op', opcode
+        def op_addi(info)
+          reg info.reg1, reg(info.reg2) + info.imm
+        end
+
+        def op_sub(info)
+          reg info.reg1, reg(info.reg2) - reg(info.reg3)
+        end
+
+        def op_mult(info)
+          reg info.reg1, reg(info.reg2) * reg(info.reg3)
+        end
+
+        def op_div(info)
+          reg info.reg1, reg(info.reg2) / reg(info.reg3)
+        end
+
+        def op_mod(info)
+          reg info.reg1, reg(info.reg2) % reg(info.reg3)
+        end
+
+        # reg1 = memory[reg2+imm]
+        def op_lw(info)
+          addr = reg(info.reg2) + info.imm
+          reg info.reg1, subsystem(:mem).read(addr)
+        end
+
+        # memory[reg1+imm] = reg2
+        def op_sw(info)
+          addr = reg(info.reg1) + info.imm
+          subsystem(:mem).write addr, reg(info.reg2)
+        end
+
+        def op_lui(info)
+          reg info.reg1, (info.imm << 32)
+        end
+
+        def op_and(info)
+          reg info.reg1, reg(info.reg2) & reg(info.reg3)
+        end
+
+        def op_andi(info)
+          reg info.reg1, reg(info.reg2) & info.imm
+        end
 
-          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])
+        def op_or(info)
+          reg info.reg1, reg(info.reg2) | reg(info.reg3)
         end
 
-        def reserved_mem
-          1024
+        def op_ori(info)
+          reg info.reg1, reg(info.reg2) | info.imm
         end
 
-        def register_unit(unit)
-          @units << unit
-          unit.vm = self
-          unit.register
+        def op_xor(info)
+          reg info.reg1, reg(info.reg2) ^ reg(info.reg3)
         end
 
-        def operand
-          operands(1)[0]
+        def op_nor(info)
+          reg info.reg1, ~(reg(info.reg2) | reg(info.reg3))
         end
 
-        def operands(n = 2)
-          flg = subsystem(:mem).read('op') & Consts::OPCODE_FLG_MASK
-          flg >> Consts::OPCODE_FLG_OFFSET
+        def op_slt(info)
+          reg info.reg1, reg(info.reg2) < reg(info.reg3) ? 1 : 0
+        end
 
-          result = []
-          n.times do
-            v = subsystem(:mem).next_cell
-            v = subsystem(:mem).read a if (flg & Consts::OPERAND_DEREFERENCE != 0)
-            result << v
-            flg << Consts::OPERAND_FLAGS
-          end
+        def op_slti(info)
+          reg info.reg1, reg(info.reg2) < info.imm ? 1 : 0
+        end
 
-          result
+        def op_slli(info)
+          reg info.reg1, reg(info.reg2) << info.imm
         end
 
-        private
+        def op_srli(info)
+          reg info.reg1, reg(info.reg2) >> info.imm
+        end
 
-        def build_struct
-          @struct = []
+        def op_sll(info)
+          reg info.reg1, reg(info.reg2) << reg(info.reg3)
+        end
 
-          @struct << Token::Label.new('null')
-          @struct << Token::Int64.new(0)
+        def op_srl(info)
+          reg info.reg1, reg(info.reg2) >> reg(info.reg3)
+        end
+
+        def op_beq(info)
+          branch(info.imm) if reg(info.reg1) == reg(info.reg2)
+        end
+
+        def op_beql(info)
+          return if reg(info.reg1) != reg(info.reg2)
+
+          reg REG_RETURN, @ip
+          branch(info.imm)
+        end
+
+        def op_bne(info)
+          branch info.imm if reg(info.reg1) != reg(info.reg2)
+        end
 
-          @struct << Token::Label.new('registers')
+        def op_bnel(info)
+          return if reg(info.reg1) == reg(info.reg2)
 
-          # instruction pointer
-          @struct << Token::Label.new('ip')
-          @struct << Token::Int64.new(0)
+          reg REG_RETURN, @ip
+          branch(info.imm)
+        end
 
-          # stack pointer
-          @struct << Token::Label.new('sp')
-          @struct << Token::Int64.new(0)
+        def op_j(info)
+          jmp info.imm
+        end
 
-          # base pointer
-          @struct << Token::Label.new('bp')
-          @struct << Token::Int64.new(0)
+        def op_jr(info)
+          @ip = reg(info.reg1)
+        end
 
-          # arithmetic registry I
-          @struct << Token::Label.new('ar')
-          @struct << Token::Int64.new(0)
+        def op_jal(info)
+          reg REG_RETURN, @ip
+          jmp info.imm
+        end
 
-          # arithmetic registry II
-          @struct << Token::Label.new('dr')
-          @struct << Token::Int64.new(0)
+        def op_exiti(info)
+          exit info.imm
+        end
 
-          # flags registry
-          @struct << Token::Label.new('fr')
-          @struct << Token::Int64.new(0)
+        def op_syscall(_info)
+          @vm.subsystem(:os).syscall
+        end
 
-          # currently processed opcode (with opcode flags)
-          @struct << Token::Label.new('op')
-          @struct << Token::Int64.new(0)
+        def reg(id, value = nil)
+          return @registers[id] if value.nil?
+          return if id == REG_ZERO # $0 cannot be overwritten
+          @registers[id] = value
+        end
 
-          # system call
-          @struct << Token::Label.new('sc')
-          @struct << Token::Int64.new(0)
+        def jmp(addr)
+          @ip = addr * Consts::WORD_SIZE
+        end
 
-          # general usage registers
-          (1..10).each do |i|
-            @struct << Token::Label.new(format('r%02d', i))
-            @struct << Token::Int64.new(0)
-          end
+        def branch(rel_addr)
+          @ip += rel_addr * Consts::WORD_SIZE
+        end
 
-          addr = 0
-          @labels = {}
-          @struct.each do |token|
-            token.absolute_addr = addr
-            addr += token.size
+        def bind_opcode(opcode, method)
+          fail "OpCode already defined - #{opcode}." if @opcodes.key? opcode
+          @opcodes[opcode] = {
+            method: method
+          }
+        end
 
-            @labels[token.label] = token if token.is_a? Token::Label
-          end
+        def iterate
+          opcode = subsystem(:mem).read @ip
+          @ip += Consts::WORD_SIZE
+          info = Utils.decode_opcode opcode
+          send @opcodes[info.cmd][:method], info
         end
       end
     end