haxor 0.1.0

data/lib/haxor/compiler/component/logical.rb

@@ -0,0 +1,43 @@
+module Haxor
+  module Compiler
+    module Component
+      class Logical < Base
+        def register
+          bind_cmd 'and', :cmd_and
+          bind_cmd 'neg', :cmd_neg
+          bind_cmd 'not', :cmd_not
+          bind_cmd 'or',  :cmd_or
+          bind_cmd 'xor', :cmd_xor
+        end
+
+        def cmd_and(a, b)
+          add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_AND | offset_flags(a, b))
+          parse_value a
+          parse_value b
+        end
+
+        def cmd_neg(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_NEG | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_not(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_NOT | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_or(a, b)
+          add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_OR | offset_flags(a, b))
+          parse_value a
+          parse_value b
+        end
+
+        def cmd_xor(a, b)
+          add Token::Cmd.new(Vm::Cpu::Unit::Logical::OP_XOR | offset_flags(a, b))
+          parse_value a
+          parse_value b
+        end
+      end
+    end
+  end
+end

data/lib/haxor/compiler/component/other.rb

@@ -0,0 +1,21 @@
+module Haxor
+  module Compiler
+    module Component
+      class Other < Base
+        def register
+          bind_cmd 'label', :cmd_label
+          bind_cmd 'rem', :cmd_rem
+          bind_cmd '#', :cmd_rem
+        end
+
+        def cmd_rem(*_args)
+          # nothing
+        end
+
+        def cmd_label(*args)
+          add Token::Label.new(args[0])
+        end
+      end
+    end
+  end
+end

data/lib/haxor/compiler/component/transfer.rb

@@ -0,0 +1,29 @@
+module Haxor
+  module Compiler
+    module Component
+      class Transfer < Base
+        def register
+          bind_cmd 'mov', :cmd_mov
+          bind_cmd 'push', :cmd_push
+          bind_cmd 'pop', :cmd_pop
+        end
+
+        def cmd_push(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Transfer::OP_PUSH | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_pop(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Transfer::OP_POP | offset_flags(a))
+          parse_value a
+        end
+
+        def cmd_mov(a, b)
+          add Token::Cmd.new(Vm::Cpu::Unit::Transfer::OP_MOV | offset_flags(a, b))
+          parse_value a
+          parse_value b
+        end
+      end
+    end
+  end
+end

data/lib/haxor/compiler/component/various.rb

@@ -0,0 +1,33 @@
+module Haxor
+  module Compiler
+    module Component
+      class Various < Base
+        def register
+          bind_cmd 'nop', :cmd_nop
+          bind_cmd 'lea', :cmd_lea
+          bind_cmd 'int', :cmd_int
+          bind_cmd 'syscall', :cmd_syscall
+        end
+
+        def cmd_nop(*_args)
+          add Token::Cmd.new(Vm::Cpu::Unit::Various::OP_NOP)
+        end
+
+        def cmd_lea(a, b)
+          add Token::Cmd.new(Vm::Cpu::Unit::Various::OP_LEA | offset_flags(a, b))
+          parse_value a
+          parse_value b
+        end
+
+        def cmd_int(a)
+          add Token::Cmd.new(Vm::Cpu::Unit::Various::OP_INT)
+          parse_value a
+        end
+
+        def cmd_syscall
+          add Token::Cmd.new(Vm::Cpu::Unit::Various::OP_SYSCALL)
+        end
+      end
+    end
+  end
+end

data/lib/haxor/compiler/core.rb

@@ -0,0 +1,134 @@
+module Haxor
+  module Compiler
+    class Core
+      def initialize
+        @units = []
+        @cmds = {}
+        @autolabel = 0
+        @prev_sections = []
+
+        bind_cmd 'section', self, :cmd_section
+      end
+
+      def register_unit(unit)
+        @units << unit
+        unit.compiler = self
+        unit.register
+      end
+
+      def bind_cmd(cmd, object, method)
+        @cmds[cmd] = {
+          object: object,
+          method: method
+        }
+      end
+
+      def cmd_section(name)
+        @unit.section = name[1..-1].to_sym
+      end
+
+      # this is ugly and must be reworked
+      def split_arguments(string)
+        inside_quotes = false
+        splits = []
+        string.each_char.with_index(0) do |x, i|
+          if x == '"' && string[i - 1] != '\\'
+            inside_quotes ^= true
+          end
+
+          if x == ',' && !inside_quotes
+            splits << i
+          end
+        end
+
+        splits << string.size
+
+        last_x = 0
+        args = []
+        splits.each do |x|
+          args << string[last_x...x]
+          last_x = x + 1
+        end
+        args.map!(&:strip).delete_if { |x| x.length == 0 }
+      end
+
+      def compile(filename)
+        input = File.read(filename, encoding: 'ASCII-8BIT')
+
+        @unit = Unit.new
+
+        input.lines.map(&:chomp).each_with_index do |line, index|
+          next if line.empty?
+
+          tmp = line.split ' ', 2
+          cmd = tmp[0]
+          args = split_arguments(tmp[1] || '')
+
+          fail "Unknown command #{cmd} in line #{index}." unless @cmds.key? cmd
+
+          @cmds[cmd][:object].send(@cmds[cmd][:method], *args)
+        end
+
+        @unit.save(filename + '.u')
+      end
+
+      def add(token)
+        @unit.add token
+      end
+
+      def parse_number(value)
+        md = value.match(/\A([-+]?[0-9]+[0-9A-F]*)([bhd]?)\z/)
+        fail if md.nil?
+
+        case md[2]
+        when 'b'
+          base = 2
+        when 'h'
+          base = 16
+        when 'd'
+        else
+          base = 10
+        end
+
+        md[1].to_i(base)
+      end
+
+      def parse_value(value)
+        value = strip_offset value
+
+        begin
+          number = parse_number(value)
+          @autolabel += 1
+          label = "__autolabel_#{@autolabel}"
+
+          old_section = @unit.section
+          @unit.section = :data
+          add Token::Label.new(label)
+          add Token::Int64.new(number)
+          @unit.section = old_section
+
+          add Token::Pointer.new(label)
+        rescue
+          add Token::Pointer.new(value)
+        end
+      end
+
+      def offset_flags(a, b = nil)
+        result = 0
+        result |= Consts::OPCODE_FLG_DA if offset?(a)
+        result |= Consts::OPCODE_FLG_DB if offset?(b)
+        result
+      end
+
+      def offset?(value)
+        return false unless value.is_a? String
+        value.start_with?('[') && value.end_with?(']')
+      end
+
+      def strip_offset(value)
+        return value[1...-1] if offset?(value)
+        value
+      end
+    end
+  end
+end

data/lib/haxor/compiler/section.rb

@@ -0,0 +1,6 @@
+module Haxor
+  module Compiler
+    class Section
+    end
+  end
+end

data/lib/haxor/compiler/unit.rb

@@ -0,0 +1,39 @@
+module Haxor
+  module Compiler
+    class Unit
+      attr_reader :section
+
+      def initialize
+        @section = :text
+        @sections = {
+          text: [],
+          data: [],
+          bss: []
+        }
+      end
+
+      def add(item)
+        @sections[@section] << item
+      end
+
+      def section=(section)
+        fail unless @sections.key? section
+        @section = section
+      end
+
+      def tokens
+        @sections[@section]
+      end
+
+      def self.load(filename)
+        Marshal.load File.read(filename)
+      end
+
+      def save(filename)
+        fd = File.open(filename, 'wb')
+        fd.write Marshal.dump(self)
+        fd.close
+      end
+    end
+  end
+end

data/lib/haxor/consts.rb

@@ -0,0 +1,28 @@
+module Haxor
+  class Consts
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+    GEM_VERSION = "#{MAJOR}.#{MINOR}.#{PATCH}"
+    VERSION = (MAJOR << 16) | (MINOR << 8) | PATCH
+
+    ROOT_PATH = __dir__ + '/../..'
+
+    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
+    OPCODE_FLG_OFFSET = 8
+    OPCODE_FLG_DA = 1 << OPCODE_FLG_OFFSET # dereference A operand
+    OPCODE_FLG_DB = 2 << OPCODE_FLG_OFFSET # dereference B operand
+
+    # Flags Registry Flags
+    FR_ZERO    = 1 << 0 # a-b == 0
+    FR_SIGN    = 1 << 1 # a-b < 0
+  end
+end

data/lib/haxor/header.rb

@@ -0,0 +1,40 @@
+module Haxor
+  class Header
+    MAGIC = 0x72_65_88_79_82 # HAXOR (ASCII)
+    SIZE = 64 # max 8 values (64bit per entry)
+
+    attr_accessor :version
+    attr_accessor :entry_point
+    attr_accessor :bss_size
+    attr_accessor :stack_size
+
+    def initialize
+      @magic = MAGIC
+    end
+
+    def dump
+      result = ''
+      result << [
+        @magic,
+        @version,
+        @entry_point,
+        @bss_size,
+        @stack_size
+      ].pack('q<*')
+      result.ljust(SIZE)
+    end
+
+    def parse!(data)
+      data = data.unpack('q<*')
+      @magic       = data.shift
+      @version     = data.shift
+      @entry_point = data.shift
+      @bss_size    = data.shift
+      @stack_size  = data.shift
+    end
+
+    def size
+      SIZE
+    end
+  end
+end

data/lib/haxor/linker.rb

@@ -0,0 +1,89 @@
+module Haxor
+  class Linker
+    attr_accessor :stack
+
+    SECTIONS = [:text, :data, :bss]
+
+    def initialize
+      @cpu = Vm::Cpu::Core.new
+      @units = []
+      @tokens = []
+      @labels = @cpu.labels.clone
+      @stack = 4096
+    end
+
+    def load_unit(filename)
+      @units << Haxor::Compiler::Unit.load(filename)
+    end
+
+    def link(filename)
+      calc_absolute_addr
+      collect_labels
+      unwind_pointers
+
+      output = File.open(filename, 'wb')
+      output.write build
+      output.close
+    end
+
+    private
+
+    def walk_tokens(type = nil)
+      SECTIONS.each do |section|
+        @units.each do |unit|
+          unit.section = section
+          unit.tokens.each do |token|
+            next unless type.nil? || token.is_a?(type)
+            yield token, section
+          end
+        end
+      end
+    end
+
+    def calc_absolute_addr
+      addr = Consts::RESERVED_MEM
+      walk_tokens do |token|
+        token.absolute_addr = addr
+        addr += token.size
+      end
+    end
+
+    def collect_labels
+      walk_tokens(Token::Label) do |token|
+        fail "Label already exists: #{token.label}." if @labels.key? token.label
+        @labels[token.label] = token
+      end
+    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
+      end
+    end
+
+    def build_header
+      bss_size = 0
+      walk_tokens do |token, section|
+        bss_size += token.size if section == :bss
+      end
+
+      hdr = Header.new
+      hdr.version = Consts::VERSION
+      hdr.entry_point = @labels['main'].absolute_addr
+      hdr.stack_size = @stack
+      hdr.bss_size = bss_size
+      hdr
+    end
+
+    def build
+      result = build_header.dump
+      walk_tokens do |token, section|
+        next unless [:text, :data].include? section
+        puts "[#{section}] [#{token.absolute_addr}] #{token}"
+        result << token.to_bytecode
+      end
+      result
+    end
+  end
+end