voodoo 1.0.2 → 1.1.1

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: voodoo
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-15 00:00:00.000000000 Z
+date: 2013-07-15 00:00:00.000000000 Z
 dependencies: []
 description: ! 'The Voodoo compiler is an implementation of the Voodoo programming
 
@@ -30,26 +30,26 @@ extensions: []
 extra_rdoc_files: []
 files:
 - bin/voodooc
-- lib/voodoo/config.rb
+- lib/voodoo.rb
 - lib/voodoo/parser.rb
-- lib/voodoo/validator.rb
-- lib/voodoo/generators/arm_gas_generator.rb~
-- lib/voodoo/generators/common_code_generator.rb
 - lib/voodoo/generators/mips_elf_generator.rb
-- lib/voodoo/generators/command_postprocessor.rb
-- lib/voodoo/generators/nasm_generator.rb
+- lib/voodoo/generators/common_code_generator.rb
 - lib/voodoo/generators/nasm_elf_generator.rb
-- lib/voodoo/generators/amd64_elf_generator.rb
-- lib/voodoo/generators/arm_elf_generator.rb
-- lib/voodoo/generators/arm_gas_generator.rb
+- lib/voodoo/generators/amd64_nasm_generator.rb
+- lib/voodoo/generators/gas_elf_generator.rb
 - lib/voodoo/generators/i386_nasm_generator.rb
+- lib/voodoo/generators/arm_gas_generator.rb
+- lib/voodoo/generators/nasm_generator.rb
 - lib/voodoo/generators/mips_gas_generator.rb
-- lib/voodoo/generators/gas_elf_generator.rb
+- lib/voodoo/generators/dummy_generator.rb
+- lib/voodoo/generators/arm_elf_generator.rb
+- lib/voodoo/generators/amd64_elf_generator.rb
 - lib/voodoo/generators/i386_elf_generator.rb
-- lib/voodoo/generators/amd64_nasm_generator.rb
+- lib/voodoo/generators/command_postprocessor.rb
 - lib/voodoo/code_generator.rb
 - lib/voodoo/compiler.rb
-- lib/voodoo.rb
+- lib/voodoo/validator.rb
+- lib/voodoo/config.rb
 homepage: http://inglorion.net/software/voodoo/
 licenses: []
 post_install_message: 

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

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