reject programs that export symbols after they have been used

[voodoo-lang.git] / lib / voodoo / generators / arm_gas_generator.rb

require 'voodoo/generators/common_code_generator'
require 'set'

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
  #   local6
  #   :
  #   localn     <-- 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, r2 and r1 are used when more
  # temporaries are needed.
  #
  # == Local Variables
  #
  # Local variables are used to store both the first 4 function arguments
  # and any variables declared inside the function (arguments beyond the 4th
  # are stored on the stack, as per the calling convention). Local variables
  # beyond the 6th are stored on the stack, starting below the saved registers
  # and counting down.
  #
  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
      # Registers used for storing local variables.
      @LOCAL_REGISTERS = [:r4, :r5, :r6, :r7, :r8, :r10]
      # Set of registers used for storing local variables.
      @LOCAL_REGISTERS_SET = Set.new @LOCAL_REGISTERS
      # Registers to be saved by save-frame.
      @SAVE_FRAME_REGISTERS = [:r4, :r5, :r6, :r7, :r8,
                               :r9, :r10, :r11, :r13, :r14]
      # Hash from register names to offsets in saved frame.
      @SAVED_FRAME_LAYOUT = {}
      @SAVE_FRAME_REGISTERS.each_with_index { |r,i| @SAVED_FRAME_LAYOUT[r] = i }
      @INITIAL_FRAME_SIZE = 2 * @WORDSIZE
      @NREGISTER_ARGS = 4
      @NREGISTER_LOCALS = @LOCAL_REGISTERS.length
      @FP = :r11
      @RETURN = :r0
      @TEMPORARIES = [:r12, :r3, :r2, :r1]
      @constants = []
      @frame_offset = 0
      @frame_size = 0
      @function_end_label = nil
      @if_labels = []
      @saved_registers = []       # registers we've saved in the current frame
      @saved_size = 0             # bytes dedicated to 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

    # 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
      if n < @NREGISTER_ARGS
        # We copied the argument to one of the local registers.
        @LOCAL_REGISTERS[n]
      else
        nil
      end
    end

    def auto_bytes value, register
      if value.kind_of? Integer
        grow_frame value
      else
        temporary = register == :sp ? @TEMPORARIES[0] : 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 == @TEMPORARIES[0] ? :r3 : @TEMPORARIES[0]
      emit "add #{register}, #{register}, \##{@STACK_ALIGNMENT - 1}\n"
      emit "mvn #{temporary}, \##{@STACK_ALIGNMENT - 1}\n"
      emit "and #{register}, #{register}, #{temporary}\n"
      emit "sub sp, #{register}\n"
    end
    
    def auto_words value, register
      if value.kind_of? Integer
        auto_bytes(value * @WORDSIZE, register)
      else
        raise "Can't use :sp as a register for auto_words" if register == :sp
        load_value_into_register value, register
        emit "lsl #{register}, #{register}, \##{@WORDSIZE_BITS}\n"
        auto_bytes_register register
        emit "cpy #{register}, sp\n"
      end
    end
    
    # Begins a new block.
    def begin_block *code
      # 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
      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

    # Define a byte with the given value
    def byte value
      emit ".byte #{value}\n"
    end

    # Call a function.
    def call func, *args
      # 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|
        with_temporary do |temporary|
          load_value_into_register args[n], temporary
          emit "str #{temporary}, " +
            "[sp , \##{(n - @NREGISTER_ARGS) * @WORDSIZE}]\n"
        end
      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], :"r#{n}"        
      end

      # Call function
      if global? func
        @symbol_tracker.use func
        emit "bl #{func}\n"
      else
        with_temporary do |temporary|
          func_reg = load_value func, temporary
          emit "blx #{func_reg}\n"
        end
      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 << @LOCAL_REGISTERS[i]
      end
      clobbered << @FP
      clobbered << :lr if save_lr
      @saved_registers = clobbered
      @saved_size = @saved_registers.length * @WORDSIZE
      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

    # Emits a comment.
    def comment text
      emit "# #{text}\n"
    end

    # Start a conditional using the specified branch instruction
    # after the comparison.
    def common_if comp, x, y = nil
      with_temporary do |temporary|
        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
    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

    # Aligns on the next multiple of +n+ bytes.
    def emit_align n
      emit ".align #{n}\n"
    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

    # Declares symbols to be exported.
    def emit_export *symbols
      symbols.each { |sym| emit ".globl #{sym}\n" }
    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 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 #{@LOCAL_REGISTERS[i]}, r#{i}\n"
      end
    end

    # Emits a label type annotation.
    def emit_label_type name, type
      type_map = {
        :code => "%function",
        :data => "%object",
      }
      emit ".type #{name}, #{type_map[type]}\n"
    end

    # Emits a label size annotation.
    def emit_label_size name
      emit ".size #{name}, .-#{name}\n"
    end

    # Loads a word into a register.
    def emit_load_word register, base, offset
      if offset == 0
        emit "ldr #{register}, [#{base}]\n"
      else
        emit "ldr #{register}, [#{base}, \##{offset * @WORDSIZE}]\n"
      end
    end

    # Stores the value of a register in memory.
    def emit_store_word register, base, offset
      if offset == 0
        emit "str #{register}, [#{base}]\n"
      else
        emit "str #{register}, [#{base}, \##{offset * @WORDSIZE}]\n"
      end
    end

    # Ends the current block.
    def end_block
      # If we are returning to top level, restore stack pointer
      # and saved registers.
      if @environment.parent == @top_level
        offset = @frame_size - @saved_size
        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 = []
        @saved_size = 0

        # 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

      label @function_end_label

      destroy_frame true
      @frame_size = 0
      @frame_offset = 0
      @saved_registers = []
      @saved_size = 0
      @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 @relocated_symbols.member? func
        call func, expr[1], expr[2]
        emit "cpy #{register}, r0\n" if register != :r0
        return
      when :mod
        func = :"__aeabi_idivmod"
        import func unless @relocated_symbols.member? func
        call func, expr[1], expr[2]
        emit "cpy #{register}, r1\n" if register != :r1
        return
      end

      with_temporaries(2) do |t1,t2|
        x = load_value expr[1], t1

        case op
        when :mul
          # Operand must be in a register for these ops.
          y = load_value expr[2], t2
        else
          y = value_ref expr[2], t2
        end

        case op
        when :bsr
          emit "lsr #{register}, #{x}, #{y}\n"
        when :or
            emit "orr #{register}, #{x}, #{y}\n"
        when :mul
          # Can't store result in same register as first operand.
          if register == x
            if x == y
              # All using the same register. Move x to a different
              # register to make this work.
              temp = (x == t1) ? t2 : t1
              emit "cpy #{temp}, #{x}\n"
              emit "mul #{register}, #{temp}, #{y}\n"
            else
              # Multiplication is commutative. Just swap x and y.
              emit "mul #{register}, #{y}, #{x}\n"
            end
          else
            # Common case, register and x are different.
            emit "mul #{register}, #{x}, #{y}\n"
          end
        when :rol
          if integer? expr[2]
            y = "\##{32 - expr[2]}"
          else
            emit "rsb #{y}, #{y}, #32\n"
          end
          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
    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
          with_temporary do |temporary|
            emit "mvn #{temporary}, #0\n"
            emit "eor #{register}, #{register}, #{temporary}\n"
          end
        else
          if binop? op
            eval_binop expr, register
          else
            raise "Not a magic word: #{op}"
          end
        end
      end
    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
        with_temporary do |temporary|
          base_reg = load_value base, temporary
          if offset == 0
            emit "ldrb #{register}, [#{base_reg}]\n"
          else
            emit "ldrb #{register}, [#{base_reg}, \##{offset}]\n"
          end
        end
      else
        with_temporaries(2) do |t1,t2|
          base_reg = load_value base, t1
          offset_reg = load_value offset, t2
          emit "ldrb #{register}, [#{base_reg}, #{offset_reg}]\n"
        end
      end
    end

    # Load word from _base_ + _offset_ * _@WORDSIZE_ into _register_
    def get_word base, offset, register
      if integer? offset
        with_temporary do |temporary|
          base_reg = load_value base, temporary
          if offset == 0
            emit "ldr #{register}, [#{base_reg}]\n"
          else
            emit "ldr #{register}, [#{base_reg}, \##{offset * @WORDSIZE}]\n"
          end
        end
      else
        with_temporaries(2) do |t1,t2|
          base_reg = load_value base, t1
          offset_reg = load_value offset, t2
          emit "ldr #{register}, [#{base_reg}, #{offset_reg}, LSL #2]\n"
        end
      end
    end

    # Jump to a label.
    def goto label
      if global? label
        emit "b #{label}\n"
      else
        with_temporary do |temporary|
          register = load_value label, temporary
          emit "cpy pc, #{register}\n"
        end
      end

      # 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
      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

    # 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
        with_temporary do |temporary|
          eval_expr expr, temporary
          emit "str #{temporary}, #{offset_reference offset}\n"
        end
      end
    end

    # Loads the value at the given address.
    def load_at address, register
      load_value_into_register address, register
      emit "ldr #{register}, [#{register}]\n"
      register
    end

    # Loads a value into some register.
    # If the value is already in a register, does nothing.
    # Else, loads the value into the register given as the
    # second argument.
    # Returns the name of the register the value is in.
    def load_value x, register
      ref = value_ref x, register
      if register? ref
        ref
      else
        emit "mov #{register}, #{ref}\n"
        register
      end
    end

    # Loads a value into a specific register.
    def load_value_into_register x, register
      ref = value_ref x, register
      if ref != register
        if register? ref
          emit "cpy #{register}, #{ref}\n"
        else
          emit "mov #{register}, #{ref}\n"
        end
      end
      register
    end

    # Returns the fp-relative reference for the nth (0-based) local.
    def local_offset n
      nstack_locals = n + number_of_register_arguments - @NREGISTER_LOCALS
      -(nstack_locals + 1) * @WORDSIZE - @saved_size
    end
    
    # Given an offset, returns an fp-relative reference.
    def offset_reference offset
      "[#{@FP}, \##{offset}]"
    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
      # 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
        with_temporaries(2) do |t1,t2|
          eval_expr expr, t1
          register = load_value symbol[1], t2
          emit "str #{t1}, [#{register}]\n"
        end
      else
        x = @environment[symbol]
        if x == nil
          raise "Cannot change value of constant #{symbol}"
        elsif x.kind_of? Symbol
          eval_expr expr, x
        else
          with_temporary do |temporary|
            eval_expr expr, temporary
            emit "str #{temporary}, #{offset_reference x}\n"
          end
        end
      end
    end

    # Set the byte at _base_ + _offset_ to _value_
    def set_byte base, offset, value
      # 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
        with_temporary do |temporary|
          load_value_into_register value, temporary
          if offset == 0
            emit "strb #{temporary}, [#{base_reg}]\n"
          else
            emit "strb #{temporary}, [#{base_reg}, \##{offset}]\n"
          end
        end
      else
        eval_binop [:add, base, offset], :a4
        with_temporary do |temporary|
          load_value_into_register value, temporary
          emit "strb #{temporary}, [a4]\n"
        end
      end
    end

    # Set the word at _base_ + _offset_ * +@WORDSIZE+ to _value_
    def set_word base, offset, value
      # 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
        with_temporary do |temporary|
          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
        end
      else
        load_value_into_register base, :a4
        with_temporary do |temporary|
          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
    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

    # Call a function, re-using the current call frame if possible.
    def tail_call func, *args
      # 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
            with_temporary do |temporary|
              emit "ldr #{temporary}, [sp, \##{saved}]\n"
              emit "str #{temporary}, #{arg_reference i}\n"
            end
          else
            # Regular value, use load_value
            with_temporary do |temporary|
              reg = load_value arg, temporary
              emit "str #{reg}, #{arg_reference i}\n"
            end
          end
        end
      end

      with_temporary do |temporary|
        # Load address of function to be called
        load_value_into_register func, temporary

        # Destroy current activation frame and enter func
        destroy_frame false
        emit "bx #{temporary}\n"
      end
      emit_constants
    end

    # Returns a reference to a value.
    # For immediate values that fit in 8 bits, this returns the
    # value itself (in ARM syntax).
    # For all other values, loads the value into a register and
    # returns the name of the register. If the value is already
    # in a register, the name of that register is returned. Else,
    # the value is loaded into the register specified as the
    # second argument.
    def value_ref x, register
      if substitution? x
        x = substitute_number x[1]
      end
        
      if integer? x
        if x >= 0 && x <= 255
          return "\##{x}"
        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? Symbol
          # 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
          @symbol_tracker.use x
          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

    # Define a word with the given value
    def word value
      emit ".int #{value}\n"
    end

  end

  # Register class for little endian ARM
  Voodoo::CodeGenerator.register_generator ARMGasGenerator,
                                           :architecture => :arm,
                                           :format => :gas
end