voodoo 1.0.1 → 1.0.2

data/lib/voodoo/config.rb

@@ -2,15 +2,15 @@ module Voodoo
   # Methods to get and set configuration parameters
   module Config
     IMPLEMENTATION_NAME = 'Voodoo Compiler'
-    IMPLEMENTATION_VERSION = '1.0.1'
+    IMPLEMENTATION_VERSION = '1.0.2'
 
     # Class that holds configuration parameters
     class Configuration
       def initialize
         @default_architecture = :auto
         @default_format = :elf
-        @gas_command = "/usr/bin/as"
-        @nasm_command = "/usr/bin/nasm"
+        @gas_command = "as"
+        @nasm_command = "nasm"
       end
 
       attr_accessor :default_format,

data/lib/voodoo/generators/arm_gas_generator.rb~

@@ -0,0 +1,957 @@
+require 'voodoo/generators/common_code_generator'
+
+module Voodoo
+  # = ARM GNU Assembler Code Generator
+  #
+  # The ARM code generator generates assembly code for use with
+  # the GNU assembler.
+  #
+  # == Calling Convention
+  #
+  # The first four arguments are passed in the registers r0 through r3.
+  # Any additional arguments are passed on the stack, starting at
+  # r13. r13 will always be a multiple of 8.
+  #
+  # The return address for the called function is passed in r14.
+  #
+  # The called function will store its return value in r0.
+  #
+  # The called function is required to preserve the values of registers
+  # r4 through r11 and register r13.
+  #
+  # This calling convention is compatible with the Procedure Call
+  # Standard for the ARM Architecture (AAPCS).
+  #
+  # == Call Frames
+  #
+  # Call frames have the following layout:
+  #
+  # When a function is called, it receives a stack frame that looks like
+  # the following:
+  #
+  #   :
+  #   old frame
+  #   padding
+  #   argn
+  #   :
+  #   arg4        <-- r13 points here
+  #
+  # The function prologue of functions generated by this code generator
+  # creates activation frames that look as follows:
+  #
+  #   :
+  #   old frame
+  #   padding
+  #   argn
+  #   :
+  #   arg4       <-- r11 points here
+  #   saved r14
+  #   saved r11
+  #   :
+  #   saved r4   <-- r13 points here
+  #
+  # == Register Usage
+  #
+  # Inside a function, registers r4..r8 and r10 are used for local variables
+  # and function arguments, whereas r11 is used as a frame pointer.
+  #
+  # r12 is used as a temporary, and r3 is used when another temporary
+  # is needed.
+  #
+  class ARMGasGenerator < CommonCodeGenerator
+    def initialize params
+      @WORDSIZE_BITS = 2
+      @WORDSIZE = 1 << @WORDSIZE_BITS
+      @CODE_ALIGNMENT = 4
+      @DATA_ALIGNMENT = @WORDSIZE
+      @FUNCTION_ALIGNMENT = @WORDSIZE
+      @STACK_ALIGNMENT_BITS = 3
+      @STACK_ALIGNMENT = 1 << @STACK_ALIGNMENT_BITS
+      
+      @INITIAL_FRAME_SIZE = 2 * @WORDSIZE
+      @NREGISTER_ARGS = 4
+      @NREGISTER_LOCALS = 6
+      @FP = :r11
+      @RETURN = :r0
+      @TEMPORARY = :r12
+      @constants = []
+      @frame_offset = 0
+      @frame_size = 0
+      @function_end_label = nil
+      @imports = {}
+      @if_labels = []
+      @saved_registers = []
+      super params
+      @output_file_suffix = '.s'
+      @features.merge! \
+        :'bits-per-word' => '32',
+        :'byte-order' => 'little-endian',
+        :'bytes-per-word' => 4
+    end
+
+    # Create an entry in the constants table,
+    # returning the label that will refer to the constant.
+    # The value may be an integer or a label.
+    def add_constant value
+      label = gensym
+      @constants << [label, value]
+      label
+    end
+
+    def align alignment = nil
+      unless alignment
+        # Get default alignment
+        case @section
+        when :code
+          alignment = @CODE_ALIGNMENT
+        when :data
+          alignment = @DATA_ALIGNMENT
+        when :function
+          alignment = @FUNCTION_ALIGNMENT
+        else
+          # Use data alignment as default
+          alignment = @DATA_ALIGNMENT
+        end
+      end
+      emit ".align #{alignment}\n" unless alignment == 0
+    end
+
+    # Returns the fp-relative offset for the nth (0-based) argument.
+    def arg_offset n
+      (n - @NREGISTER_ARGS) * @WORDSIZE
+    end
+    
+    # Returns an fp-relative reference for the nth (0-based) argument.
+    def arg_reference n
+      offset_reference arg_offset(n)
+    end
+
+    # Return the register in which the nth (0-based) argument is stored, or
+    # nil if not stored in a register
+    def arg_register n
+      # The first @NREGISTER_ARGS arguments are in the v registers,
+      # the rest are on the stack.
+      if register_arg? n
+        "v#{n + 1}"
+      else
+        nil
+      end
+    end
+
+    # Test if op is a binary operation
+    def assymetric_binop? op
+      [:asr, :bsr, :div, :mod, :rol, :ror, :shl, :shr, :sub].member?(op)
+    end
+
+    # Test if a value is an at-expression
+    def at_expr? value
+      value.respond_to?(:[]) && value[0] == :'@'
+    end
+
+    def auto_bytes value, register
+      if value.kind_of? Integer
+	grow_frame value
+      else
+	temporary = register == :sp ? @TEMPORARY : register
+        load_value_into_register value, temporary
+	auto_bytes_register temporary
+      end
+      emit "cpy #{register}, sp\n" unless register == :sp
+    end
+    
+    # auto-bytes where the value is supplied in a register and the return
+    # value will be in sp. register must not be sp.
+    def auto_bytes_register register
+      temporary = register == @TEMPORARY ? :r3 : @TEMPORARY
+      emit "add #{register}, #{register}, \##{@STACK_ALIGNMENT - 1}\n"
+      emit "mvn #{temporary}, \##{@STACK_ALIGNMENT - 1}\n"
+      emit "and #{register}, #{register}, #{temporary}\n"
+      emit "sub sp, #{temp1}\n"
+    end
+    
+    def auto_words value, register
+      if value.kind_of? Integer
+	auto_bytes(value * @WORDSIZE, register)
+      else
+	temporary = register == :sp ? @TEMPORARY : register
+	load_value_into_register value, temporary
+	emit "lsl #{temporary}, #{temporary}, \##{@WORDSIZE_BITS}\n"
+	auto_bytes_register temporary
+	emit "cpy #{register}, sp\n" unless register == :sp
+      end
+    end
+    
+    # Begins a new block.
+    def begin_block *code
+      emit "# begin block\n"
+      # If we are starting a block at top level, create a frame
+      if @environment == @top_level
+        nlocals = count_locals code
+        create_frame nlocals, false
+      end
+      @environment = Environment.new @environment
+    end
+
+    # Emit function prologue and declare _formals_ as function arguments
+    def begin_function formals, nlocals
+      if @environment != @top_level
+        raise "Can only begin a function at top level"
+      end
+
+      @function_end_label = gensym
+      emit "# function #{formals.join ' '}\n"
+      environment = Environment.new @environment
+      formals.each_with_index do |formal, i|
+	if i < @NREGISTER_ARGS
+	  environment.add_arg formal, arg_register(i)
+	else
+	  environment.add_arg formal, arg_offset(i)
+	end
+      end
+      @environment = environment
+      emit_function_prologue formals, nlocals
+    end
+
+    # Test if op is a binary operation
+    def binop? op
+      assymetric_binop?(op) || symmetric_binop?(op)
+    end
+
+    # Define a byte with the given value
+    def byte value
+      emit ".byte #{value}\n"
+    end
+
+    # Call a function.
+    def call func, *args
+      emit "# call #{func} #{args.join ' '}\n"
+
+      # Calculate how many arguments need to be pushed on
+      # the stack, and allocate space for them.
+      nstack_args = number_of_stack_arguments args.length
+      old_frame_offset = @frame_offset
+      old_frame_size = @frame_size
+      grow_frame nstack_args if nstack_args > 0
+
+      # Put stack arguments on the stack
+      (@NREGISTER_ARGS...args.length).each do |n|
+        load_value_into_register args[n], @TEMPORARY
+        emit "str #{@TEMPORARY}, " +
+          "[sp , \##{(n - @NREGISTER_ARGS) * @WORDSIZE}]\n"
+      end
+
+      # Put register arguments in the right registers
+      nregister_args = number_of_register_arguments args.length
+      nregister_args.times do |n|
+          load_value_into_register args[n], :"a#{n + 1}"        
+      end
+
+      # Call function
+      if global? func
+        emit "bl #{func}\n"
+      else
+        func_reg = load_value func
+        emit "blx #{func_reg}\n"
+      end
+
+      # Restore original stack frame
+      if old_frame_size != @frame_size
+        emit "add sp, sp, \##{@frame_size - old_frame_size}\n"
+        @frame_offset = old_frame_offset
+        @frame_size = old_frame_size
+      end
+    end
+
+    # Creates a stack frame for the given number of arguments
+    # and local variables.
+    def create_frame nvars, save_lr = true
+      # Calculate how many variables we will store in registers,
+      # and how many on the stack.
+      nregister_vars = [nvars, @NREGISTER_LOCALS].min
+      nstack_vars = nvars - nregister_vars
+
+      # Save the registers we will clobber to the stack.
+      clobbered = []
+      nregister_vars.times do |i|
+        clobbered << :"v#{i < 5 ? i + 1 : i + 2}"
+      end
+      clobbered << @FP
+      clobbered << :lr if save_lr
+      @saved_registers = clobbered
+      emit "stmfd sp!, {#{clobbered.join ', '}}\n"
+      emit "add #{@FP}, sp, \##{clobbered.length * @WORDSIZE}\n"
+
+      # Calculate frame size so that the stack pointer will
+      # be properly aligned at the end of emit_function_prologue.
+      @frame_size = stack_align((clobbered.length + nstack_vars) * @WORDSIZE)
+      extra_space = @frame_size - clobbered.length * @WORDSIZE
+      if extra_space > 0
+        emit "sub sp, sp, \##{extra_space}\n"
+      end
+      @frame_offset = 0
+    end
+
+    # Start a conditional using the specified branch instruction
+    # after the comparison.
+    def common_if comp, x, y = nil
+      emit "# #{comp} #{x} #{y}\n"
+
+      xreg = load_value x, @TEMPORARY
+      yreg = load_value y, :a4
+
+      falselabel = @environment.gensym
+      @if_labels.push falselabel
+
+      emit "cmp #{xreg}, #{yreg}\n"
+
+      lut = { :ifeq => "bne", :ifge => "blt", :ifgt => "ble",
+        :ifle => "bgt", :iflt => "bge", :ifne => "beq" }
+      emit "#{lut[comp]} #{falselabel}\n"
+    end
+
+    # Counts the number of local variables created in
+    # a sequence of statements.
+    def count_locals statements
+       count = 0
+       each_statement(statements) do |statement|
+         if statement[0] == :let
+           # let introduces a single local
+           count = count + 1
+         end
+       end
+       count
+    end
+
+    # Destroys the current stack frame.
+    # If ret is true, loads the saved value of lr into pc.
+    def destroy_frame ret = false
+      # Set sp back to where saved registers were stored
+      saved = @saved_registers
+      emit "sub sp, #{@FP}, \##{saved.length * @WORDSIZE}\n"
+
+      if ret
+        index = saved.index :lr
+        if index
+          saved[index] = :pc
+        else
+          raise "Request to load saved lr into pc, but lr has not been saved"
+        end
+      end
+      emit "ldmfd sp!, {#{saved.join ', '}}\n"
+      
+      emit_constants if ret
+    end
+
+    # Writes any constants that need to be written to the instruction
+    # stream, and clears the list of constants that need to be written.
+    def emit_constants
+      @constants.each do |x|
+        label x[0]
+        word x[1]
+      end
+      @constants = []
+    end
+
+    # Emit function prologue.
+    def emit_function_prologue formals = [], nlocals = 0
+      # Calculate the number of arguments we were passed in
+      # registers, the total number of values we need to save
+      # on the stack, then create a stack frame and save
+      # the v registers we will be using.
+      nregister_args = [formals.length, @NREGISTER_ARGS].min
+      nvars = nregister_args + nlocals
+      create_frame nvars, true
+
+      # Move arguments that were passed in registers into
+      # callee-save registers.
+      nregister_args.times do |i|
+        emit "cpy v#{i + 1}, a#{i + 1}\n"
+      end
+    end
+
+    # Ends the current block.
+    def end_block
+      emit "# end block\n"
+
+      # If we are returning to top level, restore stack pointer
+      # and saved registers.
+      if @environment.parent == @top_level
+        offset = @frame_size - @saved_registers.length * @WORDSIZE
+        if offset > 0
+          emit "add sp, sp, \##{offset}\n"
+        end
+        emit "ldmfd sp!, {#{@saved_registers.join ', '}}\n"
+        @frame_size = 0
+        @frame_offset = 0
+        @saved_registers = []
+
+        # If we need to emit constants, do so now
+        unless @constants.empty?
+          lbl = gensym
+          goto lbl
+          label lbl
+        end
+      end
+
+      # Restore old value of @environment
+      @environment = @environment.parent
+    end
+
+    # Ends a function body.
+    def end_function
+      if @environment == @top_level
+        raise "Cannot end function when not in a function"
+      end
+
+      emit "# function epilogue\n"
+      label @function_end_label
+
+      destroy_frame true
+      @frame_size = 0
+      @frame_offset = 0
+      @saved_registers = []
+      emit "# end function\n\n"
+      @environment = @top_level
+    end
+
+    # Ends a conditional.
+    def end_if
+      label @if_labels.pop
+    end
+
+    # Evaluate the binary operation expr and store the result in register
+    def eval_binop expr, register
+      op = expr[0]
+
+      # Emulation for div and mod, which ARM does not have instructions for
+      case op
+      when :div
+        func = :"__aeabi_idiv"
+        import func unless @imports.has_key? func
+        call func, expr[1], expr[2]
+        emit "cpy #{register}, r0\n" if register != :r0
+        return
+      when :mod
+        func = :"__aeabi_idivmod"
+        import func unless @imports.has_key? func
+        call func, expr[1], expr[2]
+        emit "cpy #{register}, r1\n" if register != :r1
+        return
+      end
+
+      x = load_value expr[1], :a4
+      y = load_value expr[2], @TEMPORARY
+
+      case op
+      when :bsr
+        emit "lsr #{register}, #{x}, #{y}\n"
+      when :or
+        emit "orr #{register}, #{x}, #{y}\n"
+      when :rol
+        emit "rsb #{y}, #{y}, #32\n"
+        emit "ror #{register}, #{x}, #{y}\n"
+      when :shl
+        emit "lsl #{register}, #{x}, #{y}\n"
+      when :shr
+        emit "lsr #{register}, #{x}, #{y}\n"
+      when :xor
+        emit "eor #{register}, #{x}, #{y}\n"
+      else
+        emit "#{expr[0]} #{register}, #{x}, #{y}\n"
+      end
+    end
+
+    # Evaluates the expression +expr+ and stores the result in +register+.
+    def eval_expr expr, register
+      if expr.length == 1
+        # Load value
+        load_value_into_register expr[0], register
+      else
+        # Evaluate expression
+        op = expr[0]
+        case op
+	when :'auto-bytes'
+	  auto_bytes expr[1], register
+	when :'auto-words'
+	  auto_words expr[1], register
+        when :call
+          call *expr[1..-1]
+          emit "cpy #{register}, #{@RETURN}\n" if register != @RETURN
+        when :'get-byte'
+          get_byte expr[1], expr[2], register
+        when :'get-word'
+          get_word expr[1], expr[2], register
+        when :not
+          load_value_into_register expr[1], register
+          emit "mvn #{@TEMPORARY}, #0\n"
+          emit "eor #{register}, #{register}, #{@TEMPORARY}\n"
+        else
+          if binop? op
+            eval_binop expr, register
+          else
+            raise "Not a magic word: #{op}"
+          end
+        end
+      end
+    end
+
+    # Export symbols from the current section
+    def export *symbols
+      symbols.each { |sym| emit ".globl #{sym}\n" }
+    end
+
+    # Add a function to the current section
+    def function formals, *code
+      nlocals = count_locals code
+      begin_function formals, nlocals
+      code.each { |action| add section, action }
+      end_function
+    end
+
+    # Load byte from _base_ + _offset_ into _register_
+    def get_byte base, offset, register
+      # If base is an integer, but offset isn't, swap them
+      if !integer?(offset) && integer?(base)
+        base, offset = [offset, base]
+      end
+
+      if integer? offset
+        base_reg = load_value base
+        if offset == 0
+          emit "ldrb #{register}, [#{base_reg}]\n"
+        else
+          emit "ldrb #{register}, [#{base_reg}, \##{offset}]\n"
+        end
+      else
+        base_reg = load_value base
+        offset_reg = load_value offset, :a4
+        emit "ldrb #{register}, [#{base_reg}, #{offset_reg}]\n"
+      end
+    end
+
+    # Load word from _base_ + _offset_ * _@WORDSIZE_ into _register_
+    def get_word base, offset, register
+      if integer? offset
+        base_reg = load_value base
+        if offset == 0
+          emit "ldr #{register}, [#{base_reg}]\n"
+        else
+          emit "ldr #{register}, [#{base_reg}, \##{offset * @WORDSIZE}]\n"
+        end
+      else
+        base_reg = load_value base
+        offset_reg = load_value offset, :a4
+        emit "ldr #{register}, [#{base_reg}, #{offset_reg}, LSL #2]\n"
+      end
+    end
+
+    # Test if a symbol refers to a global
+    def global? symbol
+      symbol?(symbol) && @environment[symbol] == nil
+    end
+
+    # Jump to a label.
+    def goto label
+      emit "b #{label}\n"
+
+      # If we have constants that need to be emitted, do so now
+      emit_constants
+    end
+
+    # Grows the current frame by n words, plus padding to
+    # respect alignment rules.
+    def grow_frame nwords
+      increment = stack_align(nwords * @WORDSIZE)
+      emit "sub sp, sp, \##{increment}\n"
+      @frame_size = @frame_size + increment
+      @frame_offset = @frame_offset + increment
+    end
+
+    # Start the false path of a conditional.
+    def ifelse
+      emit "# else\n"
+      newlabel = @environment.gensym
+      goto newlabel
+      lbl = @if_labels.pop
+      label lbl
+      @if_labels.push newlabel
+    end
+
+    # Test if x is equal to y
+    def ifeq x, y
+      common_if :ifeq, x, y
+    end
+
+    # Test if x is greater than or equal to y
+    def ifge x, y
+      common_if :ifge, x, y
+    end
+
+    # Test if x is strictly greater than y
+    def ifgt x, y
+      common_if :ifgt, x, y
+    end
+
+    # Test if x is less than or equal to y
+    def ifle x, y
+      common_if :ifle, x, y
+    end
+
+    # Test if x is strictly less than y
+    def iflt x, y
+      common_if :iflt, x, y
+    end
+
+    # Test if x different from y
+    def ifne x, y
+      common_if :ifne, x, y
+    end
+
+    # Import labels into the current section
+    def import *symbols
+      # Record imported labels in @imports
+      symbols.each { |sym| @imports[sym] = sym }
+    end
+
+    # Test if a value is an integer
+    def integer? value
+      value.kind_of? Integer
+    end
+
+    # Emit a label
+    def label name
+      emit "#{name}:\n"
+    end
+
+    # Introduce a new local variable
+    def let symbol, *expr
+      n = @environment.locals
+      register = local_register n
+
+      if register
+        # We will use a register to store the value
+	@environment.add_local symbol, register
+        eval_expr expr, register
+      else
+        # We will use the stack to store the value
+	offset = local_offset n
+	@environment.add_local symbol, offset
+        eval_expr expr, @TEMPORARY
+        emit "str #{@TEMPORARY}, #{offset_reference offset}\n"
+      end
+    end
+
+    # Load the value at the given address.
+    def load_at address, register = @TEMPORARY
+      load_value_into_register address, register
+      emit "ldr #{register}, [#{register}]\n"
+      register
+    end
+
+    # Load a value into a register.
+    # Returns the name of the register.
+    # If the value was already in a register, the name of that
+    # register is returned.
+    # Else, the value is loaded into a register and the name of
+    # that register is returned. The register to use in that case
+    # may be specified using the optional second argument.
+    def load_value x, register = @TEMPORARY
+      if integer? x
+        if x >= 0 && x <= 255
+          emit "mov #{register}, \##{x}\n"
+          return register
+        elsif x >= -255 && x < 0
+          emit "mvn #{register}, \##{-(x + 1)}\n"
+          return register
+        else
+          lbl = add_constant x
+          emit "ldr #{register}, #{lbl}\n"
+          return register
+        end
+      elsif symbol? x
+        binding = @environment[x]
+	if binding.kind_of? String
+	  # Value is already in a register. Return register name.
+	  return binding
+	elsif binding.kind_of? Integer
+	  # Value is on the stack. Load from the stack.
+	  emit "ldr #{register}, #{offset_reference binding}\n"
+	  return register
+	else
+          # Assume global
+          lbl = add_constant x
+          emit "ldr #{register}, #{lbl}\n"
+          return register
+        end
+      elsif at_expr? x
+        load_at x[1], register
+      else
+        raise "Don't know how to load #{x.inspect}"
+      end
+    end
+
+    # Load a value into a specific register
+    def load_value_into_register x, register
+      reg = load_value x, register
+      if reg != register
+        emit "cpy #{register}, #{reg}\n"
+      end
+    end
+
+    # Returns the fp-relative reference for the nth (0-based) local.
+    def local_offset n
+      -@INITIAL_FRAME_SIZE - (n * @WORDSIZE)
+    end
+    
+    # Return the register in which the nth local (0-based) is stored, or
+    # nil if not stored in a register
+    def local_register n
+      if register_local? n
+        n = n + number_of_register_arguments
+        if n < 5
+          "v#{n + 1}"
+        else
+          "v#{n + 2}"
+        end
+      else
+        nil
+      end
+    end
+
+    # Calculate the number of register arguments,
+    # given the total number of arguments.
+    def number_of_register_arguments n = @environment.args
+      [n, @NREGISTER_ARGS].min
+    end
+
+    # Calculate the number of stack arguments,
+    # given the total number of arguments.
+    def number_of_stack_arguments n = @environment.args
+      [0, n - @NREGISTER_ARGS].max
+    end
+
+    # Given an offset, returns an fp-relative reference.
+    def offset_reference offset
+      "[#{@FP}, \##{offset}]"
+    end
+
+    # Returns true if the nth (0-based) argument is stored in a register
+    def register_arg? n
+      n < @NREGISTER_ARGS
+    end
+
+    # Returns true if the nth (0-based) local is stored in a register
+    def register_local? n
+      (n + number_of_register_arguments) < @NREGISTER_LOCALS
+    end
+
+    # Returns from a function.
+    # 
+    # _words_ may contain an expression to be evaluated. The result
+    # of the evaluation is returned from the function.
+    def ret *words
+      emit "# return #{words.join ' '}\n"
+      # Compute return value and store it in @RETURN
+      eval_expr(words, @RETURN) unless words.empty?
+      # Go to epilogue
+      goto @function_end_label
+    end
+    
+    # Set a variable to the result of evaluating an expression
+    def set symbol, *expr
+      if at_expr? symbol
+	eval_expr expr, :r3
+	register = load_value symbol[1]
+	emit "str r3, [#{register}]\n"
+      else
+	x = @environment[symbol]
+	if x == nil
+	  raise "Cannot change value of constant #{symbol}"
+	elsif x.kind_of? String
+	  eval_expr expr, x
+	else
+	  eval_expr expr, @TEMPORARY
+	  emit "str #{@TEMPORARY}, #{offset_reference x}\n"
+	end
+      end
+    end
+
+    # Set the byte at _base_ + _offset_ to _value_
+    def set_byte base, offset, value
+      emit "# set-byte #{base} #{offset} #{value}\n"
+      # If base is an integer, but offset isn't, swap them
+      if !integer?(offset) && integer?(base)
+        base, offset = [offset, base]
+      end
+
+      if integer? offset
+        base_reg = load_value base, :a4
+        load_value_into_register value, @TEMPORARY
+        if offset == 0
+          emit "strb #{@TEMPORARY}, [#{base_reg}]\n"
+        else
+          emit "strb #{@TEMPORARY}, [#{base_reg}, \##{offset}]\n"
+        end
+      else
+        eval_binop [:add, base, offset], :a4
+        load_value_into_register value, @TEMPORARY
+        emit "strb #{@TEMPORARY}, [a4]\n"
+      end
+    end
+
+    # Set the word at _base_ + _offset_ * +@WORDSIZE+ to _value_
+    def set_word base, offset, value
+      emit "# set-word #{base} #{offset} #{value}\n"
+      # If base is an integer, but offset isn't, swap them
+      if !integer?(offset) && integer?(base)
+        base, offset = [offset, base]
+      end
+
+      if integer? offset
+        base_reg = load_value base, :a4
+        load_value_into_register value, @TEMPORARY
+        if offset == 0
+          emit "str #{@TEMPORARY}, [#{base_reg}]\n"
+        else
+          emit "str #{@TEMPORARY}, [#{base_reg}, \##{offset * @WORDSIZE}]\n"
+        end
+      else
+	load_value_into_register base, :a4
+        load_value_into_register offset, @TEMPORARY
+        emit "add a4, a4, #{@TEMPORARY}, LSL #2\n"
+        load_value_into_register value, @TEMPORARY
+        emit "str #{@TEMPORARY}, [a4]\n"
+      end
+    end
+
+    # Given n, returns the nearest multiple of @STACK_ALIGNMENT
+    # that is >= n.
+    def stack_align n
+      (n + @STACK_ALIGNMENT - 1) / @STACK_ALIGNMENT * @STACK_ALIGNMENT
+    end
+    
+    # Define a string with the given value
+    def string value
+      code = ''
+      value.each_byte do |b|
+        if b == 92
+          code << "\\\\"
+        elsif b >= 32 && b < 127 && b != 34
+          code << b.chr
+        else
+          code << sprintf("\\%03o", b)
+        end
+      end
+      emit ".ascii \"#{code}\"\n"
+    end
+
+    # Test if a value is a symbol
+    def symbol? value
+      value.kind_of? Symbol
+    end
+
+    # Test if op is a symmetric binary operation (i.e. it will yield the
+    # same result if the order of its source operands is changed).
+    def symmetric_binop? op
+      [:add, :and, :mul, :or, :xor].member? op
+    end
+
+    # Call a function, re-using the current call frame if possible.
+    def tail_call func, *args
+      emit "# tail-call #{func} #{args.join ' '}\n"      
+
+      # Compute number of stack arguments
+      nstackargs = number_of_stack_arguments args.length
+      # If we need more stack arguments than we have now,
+      # perform a normal call and return
+      if nstackargs > number_of_stack_arguments(@environment.args)
+        emit "# Not enough space for proper tail call; using regular call\n"
+        ret :call, func, *args
+      end
+
+      # We will assign arguments from left to right.
+      # Find places that we will overwrite before we read them,
+      # and store their values in some newly allocated stack space.
+      old_frame_offset = @frame_offset
+      old_frame_size = @frame_size
+      overwritten = {}
+      (@NREGISTER_ARGS...args.length).each do |i|
+        arg = args[i]
+        arg = arg[1] if at_expr? arg
+        if symbol?(arg)
+          binding = @environment[arg]
+          if binding[0] == :arg && binding[1] >= @NREGISTER_ARGS &&
+              binding[1] < i
+            # Argument i is a stack argument, but the value we will assign
+            # it is a stack argument that comes before it, so we will
+            # have overwritten it by the time we get to it.
+            overwritten[arg] = nil
+          end
+        end
+      end
+      
+      unless overwritten.empty?
+        # Allocate space for arguments to be saved
+        grow_frame overwritten.length
+        # Save values
+        offset = 0
+        overwritten.each_key do |key|
+          reg = load_value key
+          emit "str #{reg}, [sp, \##{offset}]\n"
+          overwritten[key] = offset
+          offset = offset + @WORDSIZE
+        end
+      end
+
+      # Assign arguments
+      args.each_index do |i|
+        arg = args[i]
+        if register_arg? i
+          load_value_into_register arg, "a#{i + 1}"
+        else
+          # Test if this is a value we saved
+          sym = at_expr?(arg) ? arg[1] : arg
+          saved = overwritten[sym]
+          if saved
+            # Saved value, load from stack
+            reg = @TEMPORARY
+            emit "ldr #{reg}, [sp, \##{saved}]\n"
+          else
+            # Regular value, use load_value
+            reg = load_value arg
+          end
+          emit "str #{reg}, #{arg_reference i}\n"
+        end
+      end
+
+      # Load address of function to be called into @TEMPORARY
+      load_value_into_register func, @TEMPORARY
+
+      # Destroy current activation frame and enter func
+      destroy_frame false
+      emit "bx #{@TEMPORARY}\n"
+      emit_constants
+    end
+
+    # Define a word with the given value
+    def word value
+      emit ".int #{value}\n"
+    end
+
+    # Write generated code to the given IO object.
+    def write io
+      @sections.each do |section,code|
+        unless code.empty?
+          io.puts ".section #{section.to_s}"
+          io.puts code
+          io.puts
+        end
+      end
+    end
+  end
+
+  # Register class for little endian ARM
+  Voodoo::CodeGenerator.register_generator ARMGasGenerator,
+                                           :architecture => :arm,
+                                           :format => :gas
+end

data/lib/voodoo/parser.rb

@@ -305,7 +305,7 @@ module Voodoo
     def parse_symbol
       wrap_exceptions do
         name = ''
-        while true
+        while lookahead != :eof
           case lookahead
           when "\\"
             name << parse_escape
@@ -525,6 +525,8 @@ module Voodoo
     # Else, nil is returned.
     def try_parse_token
       case lookahead
+      when :eof
+        nil
       when /\d|-/
         # Digit; parse number
         parse_number
@@ -606,8 +608,10 @@ module Voodoo
         raise
       rescue => e
         # Some other error; wrap in ParserInternalError.
-        raise ParserInternalError.new(e, @input_name, @line,
-                                      @column, @text)
+        wrapped = ParserInternalError.new(e, @input_name, @line,
+                                          @column, @text)
+        wrapped.set_backtrace e.backtrace
+        raise wrapped
       end
     end
     

metadata

@@ -1,96 +1,81 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: voodoo
-version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  - 1
-  version: 1.0.1
+version: !ruby/object:Gem::Version
+  version: 1.0.2
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Robbert Haarman
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-01-29 00:00:00 -08:00
-default_executable: 
+date: 2012-11-15 00:00:00.000000000 Z
 dependencies: []
+description: ! 'The Voodoo compiler is an implementation of the Voodoo programming
 
-description: |
-  The Voodoo compiler is an implementation of the Voodoo programming
   language, a simple low-level programming language.
-  
+
+
   The compiler can be used both as a stand-alone program to
+
   compile Voodoo source code and as a Ruby module to generate code on
+
   the fly. Multiple target platforms are supported.
 
+'
 email: voodoo@inglorion.net
-executables: 
+executables:
 - voodooc
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - bin/voodooc
-- lib/voodoo.rb
-- lib/voodoo/parser.rb
-- lib/voodoo/code_generator.rb
-- lib/voodoo/compiler.rb
 - lib/voodoo/config.rb
+- lib/voodoo/parser.rb
 - lib/voodoo/validator.rb
+- lib/voodoo/generators/arm_gas_generator.rb~
 - lib/voodoo/generators/common_code_generator.rb
-- lib/voodoo/generators/mips_gas_generator.rb
-- lib/voodoo/generators/i386_elf_generator.rb
-- lib/voodoo/generators/command_postprocessor.rb
 - lib/voodoo/generators/mips_elf_generator.rb
-- lib/voodoo/generators/gas_elf_generator.rb
-- lib/voodoo/generators/arm_elf_generator.rb
-- lib/voodoo/generators/arm_gas_generator.rb
-- lib/voodoo/generators/amd64_nasm_generator.rb
+- lib/voodoo/generators/command_postprocessor.rb
+- lib/voodoo/generators/nasm_generator.rb
 - lib/voodoo/generators/nasm_elf_generator.rb
 - lib/voodoo/generators/amd64_elf_generator.rb
-- lib/voodoo/generators/nasm_generator.rb
+- lib/voodoo/generators/arm_elf_generator.rb
+- lib/voodoo/generators/arm_gas_generator.rb
 - lib/voodoo/generators/i386_nasm_generator.rb
-has_rdoc: true
+- lib/voodoo/generators/mips_gas_generator.rb
+- lib/voodoo/generators/gas_elf_generator.rb
+- lib/voodoo/generators/i386_elf_generator.rb
+- lib/voodoo/generators/amd64_nasm_generator.rb
+- lib/voodoo/code_generator.rb
+- lib/voodoo/compiler.rb
+- lib/voodoo.rb
 homepage: http://inglorion.net/software/voodoo/
 licenses: []
-
 post_install_message: 
-rdoc_options: 
+rdoc_options:
 - -m
 - Voodoo
 - -t
 - Voodoo Code Generator API Documentation
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: voodoo
-rubygems_version: 1.3.7
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Compiler for the Voodoo programming language
 test_files: []
-