voodoo 1.0.2 → 1.1.1

data/lib/voodoo/generators/dummy_generator.rb

@@ -0,0 +1,10 @@
+module Voodoo
+  # Generator that does nothing.
+  class DummyGenerator
+    def add *args
+    end
+
+    def write *args
+    end
+  end
+end

data/lib/voodoo/generators/i386_nasm_generator.rb

@@ -31,12 +31,19 @@ module Voodoo
   #   :
   #   localn <-- esp
   #
+  # == Callee-Save Registers
+  #
+  # +ebp+, +ebx+, +edi+, +esi+, and +esp+ are callee-save registers.
+  #
+  # All other registers are caller-save registers.
+  #
   class I386NasmGenerator < NasmGenerator
     WORDSIZE = 4
 
     def initialize params = {}
       # Number of bytes in a word
-      @WORDSIZE = 4
+      @WORDSIZE_BITS = 2
+      @WORDSIZE = 1 << @WORDSIZE_BITS
       # Word name in NASM lingo
       @WORD_NAME = 'dword'
       # Default alignment for code
@@ -45,101 +52,128 @@ module Voodoo
       @DATA_ALIGNMENT = @WORDSIZE
       # Default alignment for functions
       @FUNCTION_ALIGNMENT = 16
+      # Stack alingment
+      @STACK_ALIGNMENT_BITS = @WORDSIZE_BITS
+      @STACK_ALIGNMENT = 1 << @STACK_ALIGNMENT_BITS
       # Register used for return values
-      @RETURN_REG = 'eax'
-      # Register used as scratch register
-      @SCRATCH_REG = 'ebx'
+      @RETURN_REG = :eax
       # Accumulator index
-      @AX = 'eax'
+      @AX = :eax
       # Base index
-      @BX = 'ebx'
+      @BX = :ebx
       # Count index
-      @CX = 'ecx'
+      @CX = :ecx
       # Data index
-      @DX = 'edx'
+      @DX = :edx
       # Base pointer
-      @BP = 'ebp'
+      @BP = :ebp
       # Stack pointer
-      @SP = 'esp'
+      @SP = :esp
+      # Registers used to store locals
+      @LOCAL_REGISTERS = []
+      @NLOCAL_REGISTERS = @LOCAL_REGISTERS.length
+      @LOCAL_REGISTERS_SET = Set.new @LOCAL_REGISTERS
+      @SAVE_FRAME_REGISTERS = [:ebx, :edi, :esi, :esp, :ebp]
+      @SAVED_FRAME_LAYOUT = {}
+      @SAVE_FRAME_REGISTERS.each_with_index { |r,i| @SAVED_FRAME_LAYOUT[r] = i }
+      @TEMPORARIES = [:ebx]
       super params
+      @saved_registers = []
+      in_section(:data) { emit "extern _GLOBAL_OFFSET_TABLE_\n" }
       @features.merge! \
         :'bits-per-word' => '32',
         :'byte-order' => 'little-endian',
         :'bytes-per-word' => '4'
     end
 
-    # Call a function
+    # Returns the offset of the nth argument.
+    def arg_offset n
+      8 + (n * @WORDSIZE)
+    end
+
+    # Emits function preamble and declare +formals+ as function arguments.
+    def begin_function formals, nlocals
+      environment = Environment.new @environment
+      @environment = environment
+      emit "push #{@BP}\nmov #{@BP}, #{@SP}\n"
+      formals.each_with_index do |arg,i|
+        environment.add_arg arg, arg_offset(i)
+      end
+      emit "sub #{@SP}, #{nlocals * @WORDSIZE}\n"      
+    end
+
+    # Calls a function.
     def call func, *args
-      emit "; call #{func} #{args.join ' '}\n"
       revargs = args.reverse
       revargs.each { |arg| push arg }
       use_value "call", func
       if args.length > 0
-        emit "add esp, #{WORDSIZE * args.length}\n"
+        emit "add esp, #{@WORDSIZE * args.length}\n"
       end
     end
 
-    # Emit function prologue.
-    def emit_function_prologue formals = []
-      emit "push ebp\nmov ebp, esp\n"
-    end
-
-    # Load the value of the nth argument
-    def load_arg n, reg = @SCRATCH_REG
-      "[ebp + #{n * @WORDSIZE + 8}]"
+    # Loads the address of the global offset table into the given register.
+    def load_got_address reg
+      lbl = gensym
+      emit "call #{lbl}\n"
+      emit "#{lbl}:\n"
+      emit "pop #{reg}\n"
+      emit "add #{reg}, _GLOBAL_OFFSET_TABLE_ + $$ - #{lbl} wrt ..gotpc\n"
+      reg
     end
 
-    # Load the value of the nth local variable
-    def load_local n, reg = @SCRATCH_REG
-      "[ebp - #{(n + 1) * @WORDSIZE}]"
+    # Loads a symbol from the global offset table.
+    def load_symbol_from_got symbol, reg
+      load_got_address reg
+      emit "mov #{reg}, [#{reg} + #{symbol} wrt ..got]\n"
+      reg
     end
 
-    # Introduce a new local variable
-    def let symbol, *words
-      emit "; let #{symbol} #{words.join ' '}\n"
-      @environment.add_local symbol
-      eval_expr words
-      emit "push eax\n"
+    # If the nth local is stored in a register, returns that register.
+    # Otherwise, returns the offset from the frame pointer.
+    def local_offset_or_register n
+      (n + 1) * -@WORDSIZE
     end
 
     # Push a word on the stack
     def push value
-      #emit "; push #{value}\n"
       value_ref = load_value value, "ebx"
       emit "push dword #{value_ref}\n"
     end
 
     # Call a function, re-using the current call frame if possible
     def tail_call fun, *args
-      emit "; tail-call #{fun} #{args.join ' '}\n"
       if args.length > @environment.args
         # Not enough space to do proper tail call; do normal call instead
         emit "; not enough space for proper tail call; changed to regular call\n"
         ret :call, fun, *args
       else
-        # Any value in the current frame that is passed to the called
-        # function must be copied to a local variable if it would otherwise
-        # be overwritten before it is used
-        i = args.length - 1
-        while i >= -1
-          arg = (i >= 0) ? args[i] : fun
-
-          if symbol?(arg)
-            x = @environment[arg]
-            if x && x[0] == :arg && x[1] < args.length && x[1] > i &&
-                (i >= 0 || fun != args[x[1]])
-              # Save value
-              newsym = @environment.gensym
-              let newsym, arg
-              # Change reference
-              if i >= 0
-                args[i] = newsym
-              else
-                fun = newsym
-              end
-            end
+        # If any arguments are going to be overwritten before they are
+        # used, save them to new local variables and use those instead.
+        (args.length - 1).downto(0) do |i|
+          arg = args[i]
+          next unless symbol?(arg)
+          old_arg_offset = @environment[arg]
+          next if old_arg_offset == nil || old_arg_offset < 0
+          # arg is an argument that was passed on the stack.
+          new_arg_offset = arg_offset i
+          next unless old_arg_offset > new_arg_offset
+          # arg will be overwritten before it is used.
+          # Save it in a newly created temporary variable,
+          # then use that instead.
+          newsym = @environment.gensym
+          let newsym, arg
+          args[i] = newsym
+        end
+
+        # Same for the function we will be calling.
+        if symbol?(fun)
+          offset = @environment[fun]
+          if offset != nil && offset > 0
+            newsym = @environment.gensym
+            let newsym, fun
+            func = newsym
           end
-          i = i - 1
         end
 
         # Set arguments
@@ -147,16 +181,15 @@ module Voodoo
           (args.length - 1).downto(0).each do |i|
             arg = args[i]
             
-            value_ref = load_value arg, "eax"
-            newarg_ref = "[ebp + #{(i + 2) * WORDSIZE}]"
+            value_ref = load_value arg, :eax
+            newarg_ref = "[ebp + #{arg_offset i}]"
             # Elide code if source is same as destination
             unless value_ref == newarg_ref
               if memory_operand?(value_ref)
                 emit "mov eax, #{value_ref}\n"
-                value_ref = "eax"
+                value_ref = :eax
               end
-              emit "mov #{@WORD_NAME} [ebp + #{(i + 2) * WORDSIZE}], " +
-                    "#{value_ref}\n"
+              emit "mov #{@WORD_NAME} #{newarg_ref}, #{value_ref}\n"
             end
           end
         end
@@ -168,7 +201,7 @@ module Voodoo
     end
 
     def use_value operation, value
-      value_ref = load_value value, "eax"
+      value_ref = load_value value, :eax
       emit "#{operation} #{value_ref}\n"
     end
 

data/lib/voodoo/generators/mips_gas_generator.rb

@@ -1,4 +1,5 @@
 require 'voodoo/generators/common_code_generator'
+require 'set'
 
 module Voodoo
   # = MIPS GNU Assembler Code Generator
@@ -53,9 +54,10 @@ module Voodoo
   # arg3
   # arg2
   # arg1
-  # arg0
+  # arg0       <-- $fp points here
   # return address
   # pointer to Global Offset Table
+  # saved $fp
   # local0
   # :
   # local7
@@ -77,6 +79,8 @@ module Voodoo
   #
   # - Saved pointer to global offset table (computed from $25), if necessary.
   #
+  # - Saved value of $fp, if necessary.
+  #
   # - Saved values of caller's locals 0 through 7
   #   (originally in $16 through $23), if necessary.
   #
@@ -94,22 +98,41 @@ module Voodoo
   # holding the address of the called function, and _gp_disp is the
   # offset between the beginning of the function and the global offset table.
   #
+  # Callee-Save Registers
+  #
+  # Registers $16 through $23 and $28 through $30 are callee-save.
+  #
+  # All other registers are caller-save.
+  #
   class MIPSGasGenerator < CommonCodeGenerator
     def initialize params
-      @WORDSIZE = 4
+      @WORDSIZE_BITS = 2
+      @WORDSIZE = 1 << @WORDSIZE_BITS
       @CODE_ALIGNMENT = 0
       @DATA_ALIGNMENT = @WORDSIZE
+      @STACK_ALIGNMENT_BITS = 3
+      @STACK_ALIGNMENT = 1 << @STACK_ALIGNMENT_BITS
+      @FP_OFFSET = -3 * @WORDSIZE
       @FUNCTION_ALIGNMENT = @WORDSIZE
-
-      @INITIAL_FRAME_SIZE = 2 * @WORDSIZE
+      @GP_OFFSET = -2 * @WORDSIZE
+      @INITIAL_FRAME_SIZE = 4 * @WORDSIZE
       @REGISTER_ARG_BASE = 4
       @NREGISTER_ARGS = 4
+      @LOCAL_REGISTERS = [:'$16', :'$17', :'$18', :'$19',
+                          :'$20', :'$21', :'$22', :'$23']
+      @LOCAL_REGISTERS_SET = Set.new @LOCAL_REGISTERS
       @REGISTER_LOCAL_BASE = 16
-      @NREGISTER_LOCALS = 8
+      @NREGISTER_LOCALS = @LOCAL_REGISTERS.length
+      @RA_OFFSET = -@WORDSIZE
       @RETURN = :'$2'
       @TEMPORARY = :'$1'
       @FUNCTION = :'$25'
       @GOT = :'$28'
+      @SAVE_FRAME_REGISTERS = [:'$16', :'$17', :'$18', :'$19', :'$20',
+                               :'$21', :'$22', :'$23', :'$28', :'$29',
+                               :'$30']
+      @SAVED_FRAME_LAYOUT = {}
+      @SAVE_FRAME_REGISTERS.each_with_index { |r,i| @SAVED_FRAME_LAYOUT[r] = i }
       @TEMPORARIES = [:'$8', :'$9', :'$10', :'$11',
                       :'$12', :'$13', :'$14', :'$15']
       @function_end_label = nil
@@ -117,6 +140,7 @@ module Voodoo
       @if_labels = []
       super params
       @output_file_suffix = '.s'
+      @saved_registers = []
       @features.merge! \
         :'bits-per-word' => '32',
         :'bytes-per-word' => '4'
@@ -131,37 +155,32 @@ module Voodoo
       end
     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
+    # Adds immediate to source and stores the result in target.
+    def addiu target, source, immediate, temporary = @TEMPORARY
+      if immediate >= -32768 && immediate < 32767
+        emit "addiu #{target}, #{source}, #{immediate}\n"
+      elsif source == "$0"
+        emit "lui #{target}, #{(immediate >> 16) & 0xffff}\n"
+        emit "ori #{target}, #{target}, #{immediate & 0xffff}\n"
+      else
+        addiu temporary, "$0", immediate
+        emit "addu #{target}, #{source}, #{temporary}\n"
       end
-      emit ".align #{alignment}\n" unless alignment == 0
     end
 
-    # Return the offset from $sp at which the nth (0-based) argument is
+    # Return the offset from the frame base at which the nth argument is
     # stored.
     def arg_offset n
-      @frame_size + n * @WORDSIZE
+      n * @WORDSIZE
     end
 
-    # Return 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
-      "#{arg_offset n}($sp)"
+      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
+    # Returns the register in which the nth (0-based) argument is stored, or
+    # nil if not stored in a register.
     def arg_register n
       if register_arg? n
         "$#{@REGISTER_ARG_BASE + n}"
@@ -170,19 +189,46 @@ module Voodoo
       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 n, register
+      if n.kind_of? Integer
+        # Maintain stack alignment
+        n = (n + @STACK_ALIGNMENT - 1) / @STACK_ALIGNMENT * @STACK_ALIGNMENT
+        grow_stack n
+      else
+        temporary = @TEMPORARIES.pop
+        begin
+          load_value_into_register n, register
+          emit "addi #{register}, #{@STACK_ALIGNMENT - 1}\n"
+          emit "li #{temporary}, -#{@STACK_ALIGNMENT}\n"
+          emit "and #{register}, #{register}, #{temporary}\n"
+          emit "sub $sp, #{register}\n"
+        ensure
+          @TEMPORARIES.push temporary
+        end
+      end
+      emit "move #{register}, $sp\n" unless register == "$sp"
     end
 
-    # Test if a value is an at-expression
-    def at_expr? value
-      value.respond_to?(:[]) && value[0] == :'@'
+    def auto_words n, register
+      if n.kind_of? Integer
+        auto_bytes n * @WORDSIZE, register
+      else
+        load_value_into_register n, register
+        if @STACK_ALIGNMENT_BITS > @WORDSIZE_BITS
+          bits = @STACK_ALIGNMENT_BITS - @WORDSIZE_BITS
+          emit "addi #{register}, #{(1 << bits) - 1}\n"
+          emit "srl #{register}, #{register}, #{bits}\n"
+          emit "sll #{register}, #{register}, #{@STACK_ALIGNMENT_BITS}\n"
+        else
+          emit "sll #{register}, #{register}, #{@WORDSIZE_BITS}\n"
+        end
+        emit "sub $sp, $sp, #{register}\n"
+        emit "move #{register}, $sp\n" unless register == "$sp"
+      end
     end
 
     # Begins a new block.
     def begin_block *code
-      emit "# begin block\n"
       # If we are at top-level, create a frame
       if @environment == @top_level
         create_frame count_locals(code)
@@ -191,40 +237,33 @@ module Voodoo
       @environment = environment
     end
 
-    # Emit function prologue and declare _formals_ as function arguments
+    # Emits function prologue and declare _formals_ as function arguments.
     def begin_function formals, nlocals
       if @environment != @top_level
         raise "Cannot begin function when already in a function"
       end
 
-      emit "# function #{formals.join ' '}\n"
       environment = Environment.new @environment
-      environment.add_args formals
+      @frame_size = 0
+      formals.each {|x| environment.add_arg x, arg_offset(environment.args)}
       @environment = environment
       @function_end_label = gensym
       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
+    # Defines a byte with the given value.
     def byte value
       emit ".byte #{value}\n"
     end
 
-    # Call a function.
+    # Calls a function.
     def call func, *args
-      emit "# call #{func} #{args.join ' '}\n"
       # Grow the stack frame, subject to 3 conditions:
       # 1. There must be enough space to hold all arguments
       # 2. $sp must remain a multiple of 8
       # 3. We must provide space for at least 4 words
       increment = ([args.length, 4].max * @WORDSIZE + 7) / 8 * 8
-      emit "addiu $sp, $sp, -#{increment}\n"
-      @frame_size = @frame_size + increment
+      grow_stack increment
 
       # Put arguments in the right places
       n = 0
@@ -261,18 +300,20 @@ module Voodoo
       emit "nop\n"
 
       # Restore original stack frame
-      emit "addiu $sp, $sp, #{increment}\n"
-      @frame_size = @frame_size - increment
+      grow_stack -increment
 
       # restore gp
-      emit "lw #{@GOT}, #{@frame_size - 2 * @WORDSIZE}($sp)\n"
+      emit "lw #{@GOT}, #{@GP_OFFSET}($fp)\n"
+    end
+
+    # Emits a comment.
+    def comment text
+      emit "# #{text}\n"
     end
 
-    # Start a conditional using the specified branch instruction
+    # Starts a conditional using the specified branch instruction
     # after the comparison.
     def common_if comp, x, y = nil
-      emit "# #{comp} #{x} #{y}\n"
-
       temporaries = @TEMPORARIES.dup
       xreg = load_value x, temporaries[0]
       temporaries.delete xreg
@@ -305,38 +346,32 @@ module Voodoo
       emit "nop\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
+    # Creates an activation frame which can store nlocals local variables.
+    def create_frame nlocals
+      @frame_size = @INITIAL_FRAME_SIZE
+      if nlocals > 0
+        @frame_size = @frame_size + (nlocals * @WORDSIZE + 7) / 8 * 8
+      end
+      grow_stack @frame_size
+      @saved_registers = []
+    end
+
+    def emit_align alignment
+      emit ".align #{alignment}\n"
     end
 
-    # Creates an activation frame which can store nlocals local variables
-    def create_frame nlocals
-      @frame_size = (@INITIAL_FRAME_SIZE + nlocals * @WORDSIZE + 7) / 8 * 8
-      emit "addiu $sp, $sp, -#{@frame_size}\n"
+    # Exports symbols from the current section.
+    def emit_export *symbols
+      symbols.each { |sym| emit ".globl #{sym}\n" }
     end
 
-    # Emit function prologue.
+    # Emits function prologue.
     def emit_function_prologue formals = [], nlocals = 0
       # Calculate new value for $gp
       emit "lui #{@GOT}, %hi(_gp_disp)\n"
       emit "addiu #{@GOT}, %lo(_gp_disp)\n"
       emit "addu #{@GOT}, #{@GOT}, #{@FUNCTION}\n"
 
-      # Save parameters 0 .. 3 in the stack space that the caller
-      # should have allocated for them.
-      [@NREGISTER_ARGS, formals.length].min.times do |n|
-        emit "sw $#{n + @REGISTER_ARG_BASE}, #{n * @WORDSIZE}($29)\n"
-      end
-
       create_frame nlocals
 
       # Save return address
@@ -344,55 +379,96 @@ module Voodoo
 
       # Save gp
       emit "sw #{@GOT}, #{@frame_size - 2 * @WORDSIZE}($sp)\n"
+
+      # Save fp
+      emit "sw $fp, #{@frame_size - 3 * @WORDSIZE}($sp)\n"
+
+      # Point fp at where sp was before we created the frame
+      addiu "$fp", "$sp", @frame_size
+
+      # Save parameters 0 .. 3 in the stack space that the caller
+      # should have allocated for them.
+      [@NREGISTER_ARGS, formals.length].min.times do |n|
+        ref = offset_reference(@environment[formals[n]])
+        emit "sw $#{n + @REGISTER_ARG_BASE}, #{ref}\n"
+      end
+    end
+
+    # Imports labels into the current section.
+    def emit_import *symbols
+      # Record imported labels in @imports
+      symbols.each { |sym| @imports[sym] = sym }
+    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
 
-    # End a function body
+    # Loads a word into a register.
+    def emit_load_word register, base, offset
+      emit "lw #{register}, #{offset * @WORDSIZE}(#{base})\n"
+    end
+
+    # Stores the value of a register in memory.
+    def emit_store_word register, base, offset
+      emit "sw #{register}, #{offset * @WORDSIZE}(#{base})\n"
+    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
       # Restore saved locals
       [@NREGISTER_LOCALS, @environment.locals].min.times do |n|
         emit "lw #{local_register n}, #{local_reference n}\n"
       end
+      @saved_registers = []
       # Load return address
-      emit "lw $31, #{@frame_size - @WORDSIZE}($sp)\n"
+      emit "lw $31, #{@RA_OFFSET}($fp)\n"
       # Restore stack pointer
-      emit "addiu $sp, $sp, #{@frame_size}\n"
+      emit "move $sp, $fp\n"
+      # Restore frame pointer
+      emit "lw $fp, #{@FP_OFFSET}($fp)\n"
       # Return
       emit "jr $31\n"
       emit "nop\n"
 
-      emit "# end function\n\n"
-
       @function_end_label = nil
       @environment = @top_level
     end
 
     # Ends the current block.
     def end_block
-      emit "# end block\n"
-
       # If we are returning to top level, restore stack pointer
       if @environment.parent == @top_level
-        emit "addiu $sp, $sp, #{@frame_size}\n"
+        grow_stack -@frame_size
+        @saved_registers = []
       end
 
       # Restore old value of @environment
       @environment = @environment.parent
     end
 
-    # End a conditional.
+    # Ends a conditional.
     def end_if
       label = @if_labels.pop
       emit "#{label}:\n"
     end
 
-    # Evaluate the binary operation expr and store the result in register
+    # Evaluates the binary operation expr and store the result in register.
     def eval_binop expr, register
       temporaries = @TEMPORARIES.dup
       x = load_value expr[1], temporaries[0]
@@ -433,7 +509,7 @@ module Voodoo
       end
     end
 
-    # Evaluate the expression expr and store the result in register
+    # Evaluates the expression expr and store the result in register.
     def eval_expr expr, register
       if expr.length == 1
         # Load value
@@ -442,6 +518,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 "move #{register}, #{@RETURN}\n" if register != @RETURN
@@ -461,20 +541,7 @@ module Voodoo
       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_
+    # Loads 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)
@@ -490,7 +557,7 @@ module Voodoo
       end
     end
 
-    # Load word from _base_ + _offset_ * _@WORDSIZE_ into _register_
+    # Loads word from _base_ + _offset_ * _@WORDSIZE_ into _register_.
     def get_word base, offset, register
       if integer? offset
         base_reg = load_value base
@@ -509,20 +576,24 @@ module Voodoo
       end
     end
 
-    # Test if a symbol refers to a global
-    def global? symbol
-      symbol?(symbol) && @environment[symbol] == nil
+    # Jumps to an address.
+    def goto address
+      if global? address
+        emit "j #{address}\n"
+      else
+        register = load_value address, @TEMPORARY
+        emit "jr #{register}\n"
+      end
+      emit "nop\n"
     end
 
-    # Jump to a label.
-    def goto label
-      emit "j #{label}\n"
-      emit "nop\n"
+    # Grows the stack by n bytes.
+    def grow_stack n
+      addiu "$sp", "$sp", -n
     end
 
-    # Start the false path of a conditional.
+    # Starts the false path of a conditional.
     def ifelse
-      emit "# else\n"
       newlabel = @environment.gensym
       emit "j #{newlabel}\n"
       emit "nop\n"
@@ -531,93 +602,65 @@ module Voodoo
       @if_labels.push newlabel
     end
 
-    # Test if x is equal to y
+    # Tests 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
+    # Tests 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
+    # Tests 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
+    # Tests 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
+    # Tests if x is strictly less than y
     def iflt x, y
       common_if :iflt, x, y
     end
 
-    # Test if x different from y
+    # Tests 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
+    # Introduces a new local variable.
     def let symbol, *expr
-      emit "# let #{symbol} #{expr.join ' '}\n"
       n = @environment.locals
-      @environment.add_local symbol
-
-      # Extend stack frame, if necessary.
-      # This should never be necessary, because we allocate enough
-      # space in the top-level function or block.
-      if @environment.locals > max_locals
-        $stderr.puts "WARNING: Stack frame too small. Possible BUG"
-        $stderr.puts "Frame size #{@frame_size}, max locals #{max_locals}" +
-                     ", actual locals #{@environment.locals}"
-        # Extend frame by 8 bytes, to keep $sp a multiple of 8
-        emit "addiu $sp, $sp, -8\n"
-        @frame_size = @frame_size + 8
-      end
-
       register = local_register n
       ref = local_reference n
       if register
         # We will use a register to store the value
+        @environment.add_local symbol, register
         # Save current value of register
         emit "sw #{register}, #{ref}\n"
+        @saved_registers << register
         # Set new value
         eval_expr expr, register
       else
         # We will use the stack to store the value
+        @environment.add_local symbol, local_offset(n)
         eval_expr expr, @TEMPORARY
         emit "sw #{@TEMPORARY}, #{ref}\n"
       end
     end
 
-    # Load the value at the given address.
+    # Loads the value at the given address.
     def load_at address, register = @TEMPORARY
       load_value_into_register address, register
       emit "lw #{register}, 0(#{register})\n"
       register
     end
 
-    # Load a value into a register.
+    # Loads 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.
@@ -625,39 +668,32 @@ module Voodoo
     # 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 substitution? x
+        x = substitute_number x[1]
+      end
+
       if x == 0
         return "$0"
       elsif integer? x
-        if x >= -32768 && x <= 32767
-          emit "addiu #{register}, $0, #{x}\n"
-          return register
-        else
-          emit "lui #{register}, #{x >> 16}\n"
-          emit "ori #{register}, #{register}, #{x & 0xffff}\n"
-          return register
-        end
+        addiu register, "$0", x
+        return register
       elsif symbol? x
         binding = @environment[x]
-        if binding
-          case binding[0]
-          when :arg
-            emit "lw #{register}, #{arg_reference binding[1]}\n"
-            return register
-          when :local
-            n = binding[1]
-            if register_local? n
-              return local_register(n)
-            else
-              emit "lw #{register}, #{local_reference n}\n"
-              return register
-            end
-          else
-            raise "Don't know how to load #{x.inspect}"
-          end
+        if register? binding
+          # Value is already in a register. Return register name.
+          return binding
+        elsif binding.kind_of? Integer
+          # Load value from memory.
+          emit "lw #{register}, #{offset_reference binding}\n"
+          return register
         else
           # Assume global
-          emit "lui #{register}, %hi(#{x})\n"
-          emit "addiu #{register}, %lo(#{x})\n"
+          if @relocated_symbols.include? x
+            emit "lw #{register}, %got(#{x})(#{@GOT})\n"
+          else
+            emit "lui #{register}, %hi(#{x})\n"
+            emit "addiu #{register}, %lo(#{x})\n"
+          end
           return register
         end
       elsif at_expr? x
@@ -667,7 +703,7 @@ module Voodoo
       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
@@ -675,97 +711,83 @@ module Voodoo
       end
     end
 
-    # Return the offset from $sp at which the nth (0-based) local variable is
-    # stored. For register locals this is the offset at which the saved
+    # Returns the offset from the frame base at which the nth local is stored.
+    # For register locals this is the offset at which the saved
     # value (from the calling function) is stored.
     def local_offset n
-      @frame_size - @INITIAL_FRAME_SIZE - (n + 1) * @WORDSIZE
+      -(n + 4) * @WORDSIZE
     end
 
-    # Return an $sp-relative reference for the nth (0-based) local
+    # Returns an $sp-relative reference for the nth (0-based) local.
     def local_reference n
-      "#{local_offset n}($sp)"
+      offset_reference(local_offset(n))
     end
 
-    # Return the register in which the nth local (0-based) is stored, or
-    # nil if not stored in a register
+    # Returns 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
-        "$#{@REGISTER_LOCAL_BASE + n}"
-      else
-        nil
-      end
+      @LOCAL_REGISTERS[n]
     end
 
-    # Compute the maximum number of locals that would fit in the current
+    # Computes the maximum number of locals that would fit in the current
     # frame size.
     def max_locals
-      (@frame_size - @INITIAL_FRAME_SIZE) / @WORDSIZE
-    end
-
-    # Calculate the number of stack arguments,
-    # given the total number of arguments.
-    def number_of_stack_arguments n
-      [0, n - @NREGISTER_ARGS].max
+      # + 1, because the initial frame size has room for 1 local
+      (@frame_size - @INITIAL_FRAME_SIZE) / @WORDSIZE + 1
     end
 
-    # Returns true if the nth (0-based) argument is stored in a register
-    def register_arg? n
-      n < @NREGISTER_ARGS
+    # Given an offset relative to the base of the frame, returns
+    # an reference to that memory location.
+    def offset_reference offset
+      "#{offset}($fp)"
     end
 
-    # Returns true if the nth (0-based) local is stored in a register
+    # Returns true if the nth (0-based) local is stored in a register.
     def register_local? n
       n < @NREGISTER_LOCALS
     end
 
-    # Return a from a function.
+    # 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
-
-      if x[0] == :local
-        register = local_register x[1]
-      else
-        register = nil
+    # Saves the current frame at the given location.
+    def save_frame location
+      load_value_into_register location, @TEMPORARY
+      @SAVE_FRAME_REGISTERS.each_with_index do |register,i|
+        emit "sw #{register}, #{i * @WORDSIZE}(#{@TEMPORARY})\n"
       end
+    end
 
-      if register
-        # Set new value
-        eval_expr expr, register
+    # Sets a variable to the result of evaluating an expression.
+    def set symbol, *expr
+      if at_expr? symbol
+        eval_expr expr, @RETURN
+        load_value_into_register symbol.to_s[1..-1].to_sym, @TEMPORARY
+        emit "sw #{@RETURN}, 0(#{@TEMPORARY})\n"
       else
-        case x[0]
-        when :local
-          ref = local_reference x[1]
-        when :arg
-          ref = arg_reference x[1]
+        x = @environment[symbol]
+        if x == nil
+          raise "Cannot change value of constant #{symbol}"
+        elsif register? x
+          eval_expr expr, x
         else
-          raise "??? #{sym} is neither a local nor an argument"
+          # Should be an integer.
+          eval_expr expr, @TEMPORARY
+          emit "sw #{@TEMPORARY}, #{offset_reference x}\n"
         end
-        eval_expr expr, @TEMPORARY
-        emit "sw #{@TEMPORARY}, #{ref}\n"
       end
     end
 
-    # Set the byte at _base_ + _offset_ to _value_
+    # Sets 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]
@@ -786,10 +808,8 @@ module Voodoo
       end
     end
 
-    # Set the word at _base_ + _offset_ * +@WORDSIZE+ to _value_
+    # Sets the word at _base_ + _offset_ * +@WORDSIZE+ to _value_.
     def set_word base, offset, value
-      emit "# set-word #{base} #{offset} #{value}\n"
-
       value_reg = @TEMPORARIES.pop
       load_value_into_register value, value_reg
       begin
@@ -813,7 +833,7 @@ module Voodoo
       end
     end
 
-    # Define a string with the given value
+    # Defines a string with the given value.
     def string value
       code = ''
       value.each_byte do |b|
@@ -828,21 +848,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.
+    # Calls 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,
@@ -857,17 +864,16 @@ module Voodoo
       nlocals = @environment.locals
       (@NREGISTER_ARGS...args.length).each do |i|
         x = @environment[args[i]]
-        if x && x[0] == :arg && x[1] >= @NREGISTER_ARGS && x[1] < i
-          # args[i] is a stack arg, but has an index < i
-          # That means that, by the time we get to pass arg[i] to the called
-          # function, it will have been overwritten. So we make a backup.
+        if integer?(x) && x < arg_offset(i)
+          # args[i] is in a location that will have been overwritten by the
+          # time we get around to passing argument i to the called function.
+          # Make a backup of the value before we overwrite it.
           if temporaries.empty?
             # Oh dear, we're out of temporaries.
             # Store the value in the current stack frame, extending it
             # as necessary.
             if nlocals >= max_locals
-              emit "addiu $sp, -8\n"
-              @frame_size = @frame_size + 8
+              grow_stack 8
             end
             reg = load_value args[i]
             emit "sw #{reg}, #{local_reference nlocals}\n"
@@ -911,16 +917,6 @@ module Voodoo
         load_value_into_register args[i], reg
       end
 
-      # Restore saved registers
-      [@NREGISTER_LOCALS, @environment.locals].min.times do |n|
-        emit "lw #{local_register n}, #{local_reference n}\n"
-      end
-      # Restore return address
-      emit "lw $31, #{@frame_size - @WORDSIZE}($sp)\n"
-
-      # Adjust stack pointer
-      emit "addiu $sp, #{@frame_size}\n"
-
       # Load function address
       if global? func
         if @imports.has_key? func
@@ -936,13 +932,27 @@ module Voodoo
         load_value_into_register func, "#{@FUNCTION}"
       end
 
+      # Restore saved registers
+      [@NREGISTER_LOCALS, @environment.locals].min.times do |n|
+        emit "lw #{local_register n}, #{local_reference n}\n"
+      end
+
+      # Restore return address
+      emit "lw $31, #{@RA_OFFSET}($fp)\n"
+
+      # Restore stack pointer
+      emit "move $sp, $fp\n"
+
+      # Restore frame pointer
+      emit "lw $fp, #{@FP_OFFSET}($fp)\n"
+
       # Perform call
       emit "jr #{@FUNCTION}\n"
       # brach delay slot
       emit "nop\n"
     end
 
-    # Define a word with the given value
+    # Defines a word with the given value
     def word value
       emit ".int #{value}\n"
     end