voodoo 0.7.0 → 1.0.0

data/lib/voodoo/generators/arm_gas_generator.rb

@@ -0,0 +1,927 @@
+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
+  #   saved r14
+  #   saved r11
+  #   :
+  #   saved r4   <-- r13 points here
+  #
+  # == Register Usage
+  #
+  # Inside a function, registers r4..r8, r10, and r11 are used for
+  # local variables and function arguments.
+  #
+  # r12 is used as a temporary, and r3 is used when another temporary
+  # is needed.
+  #
+  class ARMGasGenerator < CommonCodeGenerator
+    def initialize params
+      @WORDSIZE = 4
+      @CODE_ALIGNMENT = 4
+      @DATA_ALIGNMENT = @WORDSIZE
+      @FUNCTION_ALIGNMENT = @WORDSIZE
+
+      @NREGISTER_ARGS = 4
+      @NREGISTER_LOCALS = 7
+      @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 an sp-relative reference for the nth (0-based) argument.
+    def arg_reference n
+      "[sp, \##{@frame_size + (n - @NREGISTER_ARGS) * @WORDSIZE}]"
+    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
+
+    # 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
+      environment.add_args formals
+      @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 << :lr if save_lr
+      @saved_registers = clobbered
+      emit "stmfd sp!, {#{clobbered.join ', '}}\n"
+
+      # Calculate frame size so that the stack pointer will
+      # be properly aligned at the end of emit_function_prologue.
+      @frame_size = (clobbered.length + nstack_vars) * @WORDSIZE
+      if @frame_size % 8 != 0
+        @frame_size = (@frame_size + 7) / 8 * 8
+      end
+      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
+      offset = @frame_size - saved.length * @WORDSIZE
+      if offset != 0
+        emit "add sp, sp, \##{offset}\n"
+      end
+
+      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 :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 = (nwords * @WORDSIZE + 7) / 8 * 8
+      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
+      emit "# let #{symbol} #{expr.join ' '}\n"
+      n = @environment.locals
+      @environment.add_local symbol
+
+      register = local_register n
+      if register
+        # We will use a register to store the value
+        eval_expr expr, register
+      else
+        # We will use the stack to store the value
+        ref = local_reference n
+        eval_expr expr, @TEMPORARY
+        emit "str #{@TEMPORARY}, #{ref}\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
+          case binding[0]
+          when :arg
+            n = binding[1]
+            if register_arg? n
+              return arg_register(n)
+            else
+              emit "ldr #{register}, #{arg_reference binding[1]}\n"
+              return register
+            end
+          when :local
+            n = binding[1]
+            if register_local? n
+              return local_register(n)
+            else
+              emit "ldr #{register}, #{local_reference n}\n"
+              return register
+            end
+          else
+            raise "Don't know how to load #{x.inspect}"
+          end
+        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 an sp-relative reference for the nth (0-based) local.
+    def local_reference n
+      "[sp, \##{@frame_offset + (number_of_register_arguments + 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
+
+    # 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
+      emit "# set #{symbol} #{expr.join ' '}\n"
+
+      x = @environment[symbol]
+      if x == nil
+        raise "Cannot change value of constant #{symbol}"
+      end
+
+      register = nil
+      case x[0]
+      when :arg
+        register = arg_register x[1]
+      when :local
+        register = local_register x[1]
+      end
+
+      if register
+        # Set new value
+        eval_expr expr, register
+      else
+        case x[0]
+        when :local
+          ref = local_reference x[1]
+        when :arg
+          ref = arg_reference x[1]
+        else
+          raise "??? #{sym} is neither a local nor an argument"
+        end
+        eval_expr expr, @TEMPORARY
+        emit "str #{@TEMPORARY}, #{ref}\n"
+      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
+
+    # 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