voodoo 1.0.2 → 1.1.1

data/lib/voodoo/generators/arm_gas_generator.rb

@@ -1,4 +1,5 @@
 require 'voodoo/generators/common_code_generator'
+require 'set'
 
 module Voodoo
   # = ARM GNU Assembler Code Generator
@@ -44,7 +45,7 @@ module Voodoo
   #   padding
   #   argn
   #   :
-  #   arg4
+  #   arg4       <-- r11 points here
   #   saved r14
   #   saved r11
   #   :
@@ -52,30 +53,44 @@ module Voodoo
   #
   # == Register Usage
   #
-  # Inside a function, registers r4..r8, r10, and r11 are used for
-  # local variables and function arguments.
+  # 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 = 4
+      @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 = 7
+      @NREGISTER_LOCALS = @LOCAL_REGISTERS.length
+      @FP = :r11
       @RETURN = :r0
-      @TEMPORARY = :r12
+      @TEMPORARIES = [:r12, :r3, :r2, :r1]
       @constants = []
       @frame_offset = 0
       @frame_size = 0
       @function_end_label = nil
       @imports = {}
       @if_labels = []
-      @saved_registers = []
+      @saved_registers = []       # registers we've saved in the current frame
       super params
       @output_file_suffix = '.s'
       @features.merge! \
@@ -93,54 +108,62 @@ module Voodoo
       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
+    # Returns the fp-relative offset for the nth (0-based) argument.
+    def arg_offset n
+      (n - @NREGISTER_ARGS) * @WORDSIZE
     end
-
-    # Returns an sp-relative reference for the nth (0-based) argument.
+    
+    # Returns an fp-relative reference for the nth (0-based) argument.
     def arg_reference n
-      "[sp, \##{@frame_size + (n - @NREGISTER_ARGS) * @WORDSIZE}]"
+      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}"
+      if n < @NREGISTER_ARGS
+        # We copied the argument to one of the local registers.
+        @LOCAL_REGISTERS[n]
       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)
+    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
-
-    # Test if a value is an at-expression
-    def at_expr? value
-      value.respond_to?(:[]) && value[0] == :'@'
+    
+    # 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
-      emit "# begin block\n"
       # If we are starting a block at top level, create a frame
       if @environment == @top_level
         nlocals = count_locals code
@@ -156,18 +179,18 @@ module Voodoo
       end
 
       @function_end_label = gensym
-      emit "# function #{formals.join ' '}\n"
       environment = Environment.new @environment
-      environment.add_args formals
+      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"
@@ -175,8 +198,6 @@ module Voodoo
 
     # 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
@@ -186,23 +207,27 @@ module Voodoo
 
       # 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"
+        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], :"a#{n + 1}"        
+          load_value_into_register args[n], :"r#{n}"        
       end
 
       # Call function
       if global? func
         emit "bl #{func}\n"
       else
-        func_reg = load_value func
-        emit "blx #{func_reg}\n"
+        with_temporary do |temporary|
+          func_reg = load_value func, temporary
+          emit "blx #{func_reg}\n"
+        end
       end
 
       # Restore original stack frame
@@ -224,18 +249,17 @@ module Voodoo
       # Save the registers we will clobber to the stack.
       clobbered = []
       nregister_vars.times do |i|
-        clobbered << :"v#{i < 5 ? i + 1 : i + 2}"
+        clobbered << @LOCAL_REGISTERS[i]
       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 = (clobbered.length + nstack_vars) * @WORDSIZE
-      if @frame_size % 8 != 0
-        @frame_size = (@frame_size + 7) / 8 * 8
-      end
+      @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"
@@ -243,35 +267,26 @@ module Voodoo
       @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
-      emit "# #{comp} #{x} #{y}\n"
-
-      xreg = load_value x, @TEMPORARY
-      yreg = load_value y, :a4
+      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
+        falselabel = @environment.gensym
+        @if_labels.push falselabel
 
-    # 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
+        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.
@@ -279,10 +294,7 @@ module Voodoo
     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
+      emit "sub sp, #{@FP}, \##{saved.length * @WORDSIZE}\n"
 
       if ret
         index = saved.index :lr
@@ -293,10 +305,15 @@ module Voodoo
         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
@@ -312,7 +329,7 @@ module Voodoo
       # 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.
+      # the registers we will be using.
       nregister_args = [formals.length, @NREGISTER_ARGS].min
       nvars = nregister_args + nlocals
       create_frame nvars, true
@@ -320,14 +337,44 @@ module Voodoo
       # 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"
+        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
-      emit "# end block\n"
-
       # If we are returning to top level, restore stack pointer
       # and saved registers.
       if @environment.parent == @top_level
@@ -358,14 +405,12 @@ module Voodoo
         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
 
@@ -394,25 +439,55 @@ module Voodoo
         return
       end
 
-      x = load_value expr[1], :a4
-      y = load_value expr[2], @TEMPORARY
+      with_temporaries(2) do |t1,t2|
+        x = load_value expr[1], t1
 
-      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"
+        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
 
@@ -425,6 +500,10 @@ module Voodoo
         # 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
@@ -434,8 +513,10 @@ module Voodoo
           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"
+          with_temporary do |temporary|
+            emit "mvn #{temporary}, #0\n"
+            emit "eor #{register}, #{register}, #{temporary}\n"
+          end
         else
           if binop? op
             eval_binop expr, register
@@ -451,14 +532,6 @@ module Voodoo
       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
@@ -467,43 +540,53 @@ module Voodoo
       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"
+        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
-        base_reg = load_value base
-        offset_reg = load_value offset, :a4
-        emit "ldrb #{register}, [#{base_reg}, #{offset_reg}]\n"
+        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
-        base_reg = load_value base
-        if offset == 0
-          emit "ldr #{register}, [#{base_reg}]\n"
-        else
-          emit "ldr #{register}, [#{base_reg}, \##{offset * @WORDSIZE}]\n"
+        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
-        base_reg = load_value base
-        offset_reg = load_value offset, :a4
-        emit "ldr #{register}, [#{base_reg}, #{offset_reg}, LSL #2]\n"
+        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
 
-    # 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 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
@@ -512,7 +595,7 @@ module Voodoo
     # Grows the current frame by n words, plus padding to
     # respect alignment rules.
     def grow_frame nwords
-      increment = (nwords * @WORDSIZE + 7) / 8 * 8
+      increment = stack_align(nwords * @WORDSIZE)
       emit "sub sp, sp, \##{increment}\n"
       @frame_size = @frame_size + increment
       @frame_offset = @frame_offset + increment
@@ -520,7 +603,6 @@ module Voodoo
 
     # Start the false path of a conditional.
     def ifelse
-      emit "# else\n"
       newlabel = @environment.gensym
       goto newlabel
       lbl = @if_labels.pop
@@ -564,140 +646,69 @@ module Voodoo
       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
+	@environment.add_local symbol, register
         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"
+	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
 
-    # Load the value at the given address.
-    def load_at address, register = @TEMPORARY
+    # 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
 
-    # 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
+    # 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
-        raise "Don't know how to load #{x.inspect}"
+        emit "mov #{register}, #{ref}\n"
+        register
       end
     end
 
-    # Load a value into a specific register
+    # Loads 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}"
+      ref = value_ref x, register
+      if ref != register
+        if register? ref
+          emit "cpy #{register}, #{ref}\n"
         else
-          "v#{n + 2}"
+          emit "mov #{register}, #{ref}\n"
         end
-      else
-        nil
       end
+      register
     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
+    # Returns the fp-relative reference for the nth (0-based) local.
+    def local_offset n
+      -@INITIAL_FRAME_SIZE - ((n + number_of_register_arguments) * @WORDSIZE)
     end
-
-    # Returns true if the nth (0-based) argument is stored in a register
-    def register_arg? n
-      n < @NREGISTER_ARGS
+    
+    # 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
@@ -710,50 +721,37 @@ module Voodoo
     # _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"
+      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
-        eval_expr expr, @TEMPORARY
-        emit "str #{@TEMPORARY}, #{ref}\n"
+      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
-      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]
@@ -761,22 +759,25 @@ module Voodoo
 
       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"
+        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
-        load_value_into_register value, @TEMPORARY
-        emit "strb #{@TEMPORARY}, [a4]\n"
+        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
-      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]
@@ -784,18 +785,22 @@ module Voodoo
 
       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"
+        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
-        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"
+        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
 
@@ -814,21 +819,8 @@ module Voodoo
       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,
@@ -883,41 +875,82 @@ module Voodoo
           saved = overwritten[sym]
           if saved
             # Saved value, load from stack
-            reg = @TEMPORARY
-            emit "ldr #{reg}, [sp, \##{saved}]\n"
+            with_temporary do |temporary|
+              emit "ldr #{temporary}, [sp, \##{saved}]\n"
+              emit "str #{temporary}, #{arg_reference i}\n"
+            end
           else
             # Regular value, use load_value
-            reg = load_value arg
+            with_temporary do |temporary|
+              reg = load_value arg, temporary
+              emit "str #{reg}, #{arg_reference i}\n"
+            end
           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
+      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"
+        # 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
+          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
 
-    # 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