voodoo 1.0.2 → 1.1.1

data/lib/voodoo/generators/nasm_generator.rb

@@ -12,15 +12,16 @@ module Voodoo
   #
   # To use the functionality from this class, a subclass must define the
   # following methods and constants:
-  # - #emit_function_prologue
-  # - #load_arg
-  # - #load_local
+  # - #begin_function
   # - @CODE_ALIGNMENT
   # - @DATA_ALIGNMENT
   # - @FUNCTION_ALIGNMENT
-  # - @SCRATCH_REG
+  # - @STACK_ALIGNMENT
+  # - @STACK_ALIGNMENT_BITS
+  # - @TEMPORARIES
   # - @WORD_NAME
   # - @WORDSIZE
+  # - @WORDSIZE_BITS
   # - @AX, @BX, @CX, @DX, @BP, and @SP
   class NasmGenerator < CommonCodeGenerator
     def initialize params = {}
@@ -35,26 +36,44 @@ module Voodoo
 
     # Export symbols from the current section
     def export *symbols
-      emit "global #{symbols.join ', '}\n"
+      case real_section_name(section)
+      when ".text"
+        symbols.each { |sym| emit "global #{sym}:function\n" }
+      else
+        @relocated_symbols.merge symbols
+        symbols.each { |sym| emit "global #{sym}:data #{sym}.end-#{sym}\n" }
+      end
     end
 
     # Continue execution at the given address
     def goto value
-      emit "; goto #{value}\n"
-      value_ref = load_value value, @SCRATCH_REG
-      emit "jmp #{value_ref}\n"
+      with_temporary do |temporary|
+        value_ref = load_value value, temporary
+        emit "jmp #{value_ref}\n"
+      end
     end
 
     # Import labels into the current section
     def import *symbols
+      if real_section_name(section) != ".text"
+        @relocated_symbols.merge symbols
+      end
       emit "extern #{symbols.join ', '}\n"
     end
 
-    # Define a label in the current section
-    def label name
+    # Emits a label.
+    def emit_label name
       emit "#{name}:\n"
     end
 
+    def emit_label_size name
+      emit ".end:\n"
+    end
+
+    def emit_label_type name, type
+      # nothing to do
+    end
+
     #
     # == Data definition
     #
@@ -105,45 +124,21 @@ module Voodoo
     # == Alignment
     #
 
-    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
+    def emit_align alignment
+      emit "align #{alignment}\n"
     end
 
     #
     # == Functions
     #
 
-    # Emit function preamble and declare _formals_ as function arguments
-    def begin_function *formals
-      emit "; function #{formals.join ' '}\n"
-      environment = Environment.new @environment
-      environment.add_args formals
-      @environment = environment
-      emit_function_prologue formals
-    end
-
-    # Emit function epilogue.
+    # Emits function epilogue.
     def emit_function_epilogue formals = []
       emit "leave\n"
     end
 
-    # End a function body
+    # Ends a function body
     def end_function
-      emit "; end function\n\n"
       if @environment == @top_level
         raise "Cannot end function when not in a function"
       else
@@ -151,12 +146,11 @@ module Voodoo
       end
     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"
       eval_expr(words) unless words.empty?
       emit_function_epilogue
       emit "ret\n"
@@ -168,7 +162,6 @@ module Voodoo
 
     # Begins a new block.
     def begin_block *code
-      emit "; begin block\n"
       # If entering a block at top level,
       # Save @BP, then set @BP to @SP
       if @environment == @top_level
@@ -181,79 +174,116 @@ module Voodoo
 
     # Ends the current block.
     def end_block
-      emit "; end block\n"
-
-      # De-allocate block's variables
-      nvars = @environment.locals - @environment.parent.locals
-      emit "add #{@SP}, #{nvars * @WORDSIZE}\n" unless nvars == 0
-
       # Restore old value of @environment
       @environment = @environment.parent
 
       # If returning to top level, restore old @BP
-      emit "pop #{@BP}\n" if @environment == @top_level
+      emit "leave\n" if @environment == @top_level
     end
 
     #
-    # == Conditionals
+    # == Memory Allocation
     #
 
-    # End a conditional body
-    def end_if
-      label = @if_labels.pop
-      emit "#{label}:\n"
+    # Allocates n bytes on the stack and stores a pointer to the allocated
+    # memory in the specified register. The number of bytes is rounded up
+    # to the nearest multiple of @STACK_ALIGNMENT.
+    def auto_bytes n, register = @RETURN_REG
+      if n.kind_of? Integer
+        auto_bytes_immediate n, register
+      else
+        load_value_into_register n, register
+        auto_bytes_register register, register
+      end
     end
 
-    #
-    # == Value Classification
-    #
+    # Implements auto_bytes where the number of bytes to allocate is given
+    # as an immediate value.
+    def auto_bytes_immediate nbytes, register
+      nbytes = ((nbytes + @STACK_ALIGNMENT - 1) >> @STACK_ALIGNMENT_BITS) <<
+        @STACK_ALIGNMENT_BITS
+      emit "sub #{@SP}, #{nbytes}\n"
+      emit "mov #{register}, #{@SP}\n" if register != @SP
+    end
 
-    # Test if a value is an at-expression
-    def at_expr? value
-      value.respond_to?(:[]) && value[0] == :'@'
+    # Implements auto_bytes where the number of bytes is supplied in a
+    # register.
+    def auto_bytes_register nbytes, register = @RETURN_REG
+      emit "add #{nbytes}, #{@STACK_ALIGNMENT - 1}\n"
+      emit "shr #{nbytes}, #{@STACK_ALIGNMENT_BITS}\n"
+      emit "shl #{nbytes}, #{@STACK_ALIGNMENT_BITS}\n"
+      emit "sub #{@SP}, #{nbytes}\n"
+      emit "mov #{register}, #{@SP}\n" if register != @SP
     end
 
-    # Test if op is a binary operation
-    def binop? op
-      [:asr, :bsr, :div, :mod, :rol, :ror, :shl, :shr, :sub].member?(op) ||
-        symmetric_operation?(op)
+    # Allocates n words on the stack and stores a pointer to the allocated
+    # memory in the specified register.
+    def auto_words n, register = @RETURN_REG
+      if n.kind_of? Integer
+        auto_bytes_immediate n * @WORDSIZE, register
+      else
+        load_value_into_register n, register
+        if @STACK_ALIGNMENT_BITS > @WORDSIZE_BITS
+          emit "add #{register}, " +
+            "#{(1 << @STACK_ALIGNMENT_BITS >> @WORDSIZE_BITS) - 1}\n"
+          emit "shr #{register}, #{@STACK_ALIGNMENT_BITS - @WORDSIZE_BITS}\n"
+          emit "shl #{register}, #{STACK_ALIGNMENT_BITS}\n"
+        else
+          emit "shl #{register}, #{@WORDSIZE_BITS}\n"
+        end
+        emit "sub #{@SP}, #{register}\n"
+        emit "mov #{register}, #{@SP}\n" if register != @SP
+      end
     end
 
-    # Test if a value is an integer
-    def integer? value
-      value.kind_of? Integer
+    #
+    # == Variables
+    #
+
+    # Introduces a new local variable.
+    def let symbol, *words
+      loc = local_offset_or_register @environment.locals
+      @environment.add_local symbol, loc
+      set symbol, *words
     end
 
-    # Test if a symbol refers to a global
-    def global? symbol
-      symbol?(symbol) && @environment[symbol] == nil
+    #
+    # == Conditionals
+    #
+
+    # End a conditional body
+    def end_if
+      label = @if_labels.pop
+      emit "#{label}:\n"
     end
 
+    #
+    # == Value Classification
+    #
+
     # Tests if an operand is an immediate operand
     def immediate_operand? operand
-      integer?(operand) || global?(operand)
+      integer?(operand)
     end
 
     # Tests if an operand is a memory operand
     def memory_operand? operand
-      operand[0] == ?[
-    end
-
-    # Test if a value is a symbol
-    def symbol? value
-      value.kind_of? Symbol
-    end
-
-    # Test if op is a symmetric operation (i.e. it will yield the
-    # same result if the order of its source operands is changed).
-    def symmetric_operation? op
-      [:add, :and, :mul, :or, :xor].member? op
+      operand.kind_of?(String) && operand[0] == ?[
     end
 
     #
     # == Loading Values
     #
 
+    # Loads a word into a register.
+    def emit_load_word register, base, offset = 0
+      if offset == 0
+        emit "mov #{register}, [#{base}]\n"
+      else
+        emit "mov #{register}, [#{base} + #{offset} * #{@WORDSIZE}]\n"
+      end
+    end
+
     # Create a value reference to an address.
     # Invoking this code may clobber @BX and/or @CX
     def load_address base, offset, scale
@@ -302,8 +332,9 @@ module Voodoo
 
     # Load the value at the given address.
     # Invoking this code may clobber @BX.
-    def load_at address, reg = @SCRATCH_REG
-      if integer?(address) || global?(address)
+    def load_at address, reg
+      if integer?(address) || (global?(address) && 
+                               !@relocated_symbols.include?(address))
         "[#{address}]"
       else
         load_value_into_register address, @BX
@@ -311,31 +342,41 @@ module Voodoo
       end
     end
 
-    # Load the value associated with the given symbol.
-    # Returns a string that can be used to refer to the loaded value.
-    def load_symbol symbol, reg = @SCRATCH_REG
+    # Loads the value associated with the given symbol.
+    def load_symbol symbol, reg
       x = @environment[symbol]
-      if x
-        case x[0]
-        when :arg
-          load_arg x[1], reg
-        when :local
-          load_local x[1], reg
-        else
-          raise "Invalid variable type: #{x[0]}"
-        end
+      if x.kind_of? Symbol
+        x
+      elsif x.kind_of? Integer
+        offset_reference x
       else
         # Assume global
-        symbol.to_s
+        if @relocated_symbols.include? symbol
+          load_symbol_from_got symbol, reg
+        else
+          symbol
+        end
       end
     end
     
-    # Load a value.
+    # Loads a value.
     # Returns a string that can be used to refer to the loaded value.
-    def load_value value, reg = @SCRATCH_REG
+    def load_value value, reg
+      if substitution? value
+        value = substitute_number value[1]
+      end
+
       if integer? value
-        # Integers can be used as is
-        value
+        if @WORDSIZE > 4 && (value < -2147483648 || value > 2147483647)
+          # AMD64 can load immediate values that are outside the range
+          # that can be represented as a 32-bit signed integer, but
+          # only with a mov instruction that loads the value into a
+          # register.
+          emit "mov #{@WORD_NAME} #{reg}, #{value}\n"
+          reg
+        else
+          value
+        end
       elsif symbol? value
         load_symbol value, reg
       elsif at_expr? value
@@ -345,20 +386,25 @@ module Voodoo
       end
     end
 
-    # Load a value into a register.
+    # Loads a value into a register.
     def load_value_into_register value, register
-      load_code = load_value(value), register
-      if load_code == register.to_s
-        load_code
-      else
-        "mov #{register}, #{load_code}\n"
-      end
+      value_ref = load_value value, register
+      set_register register, value_ref
     end
 
     #
     # == Storing Values
     #
 
+    # Stores the value of a register in memory.
+    def emit_store_word register, base, offset = 0
+      if offset == 0
+        emit "mov [#{base}], #{register}\n"
+      else
+        emit "mov [#{base} + #{offset} * #{@WORDSIZE}], #{register}\n"
+      end
+    end
+
     # Evaluate the expr in words and store the result in target
     def set target, *words
       if integer? target
@@ -367,35 +413,10 @@ module Voodoo
         raise "Cannot change value of global #{target}"
       end
 
-      emit "; set #{target} #{words.join ' '}\n"
-      if words.length == 1
-        if words[0] == target
-          emit "; nothing to do; destination equals source\n"
-        else
-          target_ref = load_value target, @BX
-          if integer?(words[0])
-            if words[0].to_i == 0
-              # Set destination to 0
-              emit "xor #{@AX}, #{@AX}\n"
-              emit "mov #{target_ref}, #{@AX}\n"
-            else
-              # Load immediate
-              emit "mov #{@WORD_NAME} #{target_ref}, #{words[0]}\n"
-            end
-          else
-            # Copy source to destination
-            eval_expr words, @RETURN_REG
-            emit "mov #{target_ref}, #{@RETURN_REG}\n"
-          end
-        end
-      else
-        op = words[0]
-
-        if words.length == 3 && binop?(op)
-          # Binary operation
-          binop op, target, words[1], words[2]
+      if words.length != 1 || words[0] != target
+        if symbol?(target) && symbol?(@environment[target])
+          eval_expr words, @environment[target]
         else
-          # Not a binary operation
           eval_expr words, @RETURN_REG
           target_ref = load_value target, @BX
           emit "mov #{target_ref}, #{@RETURN_REG}\n"
@@ -405,12 +426,11 @@ module Voodoo
 
     # Set the byte at _base_ + _offset_ to _value_
     def set_byte base, offset, value
-      emit "; set-byte #{base} #{offset} #{value}\n"
       if immediate_operand?(value)
         value_ref = value
       else
         load_value_into_register value, @RETURN_REG
-        value_ref = "al"
+        value_ref = :al
       end
       addr_ref = load_address base, offset, 1
       emit "mov byte #{addr_ref}, #{value_ref}\n"
@@ -418,9 +438,8 @@ module Voodoo
 
     # Set the word at _base_ + _offset_ * +@WORDSIZE+ to _value_
     def set_word base, offset, value
-      emit "; set-word #{base} #{offset} #{value}\n"
       if immediate_operand?(value)
-        value_ref = value
+        value_ref = load_value value, @RETURN_REG
       else
         load_value_into_register value, @RETURN_REG
         value_ref = @RETURN_REG
@@ -429,69 +448,6 @@ module Voodoo
       emit "mov #{@WORD_NAME} #{addr_ref}, #{value_ref}\n"
     end
 
-    #
-    # == Binary Operations
-    #
-
-    # Emit code for a binary operation
-    def binop op, target, x, y
-      if target == x
-        binop2 op, target, y
-      elsif symmetric_operation?(op) && y == target
-        binop2 op, target, x
-      else
-        # Cases that are handled specially
-        return div(target, x, y) if op == :div
-        return mod(target, x, y) if op == :mod
-        return mul(target, x, y) if op == :mul
-
-        target_ref = load_value target, @BX
-        x_ref = load_value x, @DX
-        y_ref = load_value y, @CX
-
-        mnemonic = action_to_mnemonic op
-        if [:asr, :bsr, :rol, :ror, :shl, :shr].member? op
-          emit "mov cl, #{y_ref}\n" unless y_ref == @CX
-          y_ref = 'cl'
-        end
-
-        if memory_operand?(target_ref)
-          if memory_operand?(x_ref) || memory_operand?(y_ref)
-            emit "mov #{@AX}, #{x_ref}\n"
-            emit "#{mnemonic} #{@AX}, #{y_ref}\n"
-            emit "mov #{target_ref}, #{@AX}\n"
-          else
-            emit "mov #{@WORD_NAME} #{target_ref}, #{x_ref}\n"
-            emit "#{mnemonic} #{@WORD_NAME} #{target_ref}, #{y_ref}\n"
-          end
-        else
-          raise "Can't happen: target_ref is #{target_ref.inspect}"
-        end
-      end
-    end
-
-    # Emit code for a binary operation where the first operand
-    # is also the target
-    def binop2 op, target, y
-      # Cases that are handled specially
-      return div2(target, target, y) if op == :div
-      return mod2(target, y) if op == :mod
-      return mul2(target, y) if op == :mul
-
-      target_ref = load_value target, @AX
-      y_ref = load_value y, @CX
-      mnemonic = action_to_mnemonic op
-      if [:asr, :bsr, :rol, :ror, :shl, :shr].member? op
-        emit "mov cl, #{y_ref}\n" unless y_ref == @CX
-        emit "#{mnemonic} #{@WORD_NAME} #{target_ref}, cl\n"
-      elsif memory_operand?(target_ref) && memory_operand?(y_ref)
-        emit "mov #{@CX}, #{y_ref}\n"
-        emit "#{mnemonic} #{target_ref}, #{@CX}\n"
-      else
-        emit "#{mnemonic} #{@WORD_NAME} #{target_ref}, #{y_ref}\n"
-      end
-    end
-
     # Divide x by y and store the quotient in target
     def div target, x, y
       eval_div x, y
@@ -535,15 +491,17 @@ module Voodoo
     # Perform division.
     # The quotient is stored in @AX, the remainder in @DX.
     def eval_div x, y
-      x_ref = load_value_into_register x, @AX
-      y_ref = load_value y, @SCRATCH_REG
-      emit "mov #{@DX}, #{@AX}\n"
-      emit "sar #{@DX}, #{@WORDSIZE * 8 - 1}\n"
-      if immediate_operand?(y_ref)
-        set_register @BX, y_ref
-        emit "idiv #{@BX}\n"
-      else
-        emit "idiv #{@WORD_NAME} #{y_ref}\n"
+      with_temporary do |temporary|
+        x_ref = load_value_into_register x, @AX
+        y_ref = load_value y, temporary
+        emit "mov #{@DX}, #{@AX}\n"
+        emit "sar #{@DX}, #{@WORDSIZE * 8 - 1}\n"
+        if immediate_operand?(y_ref)
+          set_register @BX, y_ref
+          emit "idiv #{@BX}\n"
+        else
+          emit "idiv #{@WORD_NAME} #{y_ref}\n"
+        end
       end
     end
 
@@ -561,33 +519,45 @@ module Voodoo
         op = words[0]
         case op
         when :asr, :bsr, :rol, :ror, :shl, :shr
-          load_value_into_register words[2], @CX
+          if integer? words[2]
+            y_ref = words[2]
+          else
+            load_value_into_register words[2], @CX
+            y_ref = :cl
+          end
           load_value_into_register words[1], register
-          emit "#{action_to_mnemonic op} #{register}, cl\n"
+          emit "#{action_to_mnemonic op} #{register}, #{y_ref}\n"
+        when :'auto-bytes'
+          auto_bytes words[1], register
+        when :'auto-words'
+          auto_words words[1], register
         when :call
           call *words[1..-1]
+          emit "mov #{register}, #{@RETURN_REG}\n" if register != @RETURN_REG
         when :div
           eval_div words[1], words[2]
           set_register register, @AX
         when :'get-byte'
-          # Clear register
-          set_register register, 0
           # Get address reference
           address_ref = load_address words[1], words[2], 1
           # Load byte from address
           case register
-          when 'eax', 'rax'
-            set_register 'al', address_ref
-          when 'ebx', 'rbx'
-            set_register 'bl', address_ref
-          when 'ecx', 'rcx'
-            set_register 'cl', address_ref
-          when 'edx', 'rdx'
-            set_register 'dl', address_ref
+          when :eax, :rax
+            set_register register, 0
+            set_register :al, address_ref
+          when :ebx, :rbx
+            set_register register, 0
+            set_register :bl, address_ref
+          when :ecx, :rcx
+            set_register register, 0
+            set_register :cl, address_ref
+          when :edx, :rdx
+            set_register register, 0
+            set_register :dl, address_ref
           else
-            set_register @BX, 0
-            set_register 'bl', address_ref
-            set_register register, @BX
+            set_register @AX, 0
+            set_register :al, address_ref
+            set_register register, @AX
           end
         when :'get-word'
           address_ref = load_address words[1], words[2], @WORDSIZE
@@ -604,7 +574,7 @@ module Voodoo
           if binop?(op)
             x_ref = load_value words[1], @DX
             y_ref = load_value words[2], @BX
-            emit "mov #{register}, #{x_ref}\n"
+            emit "mov #{register}, #{x_ref}\n" unless register == x_ref
             emit "#{op} #{register}, #{y_ref}\n"
           else
             raise "Not a magic word: #{words[0]}"
@@ -629,9 +599,11 @@ module Voodoo
         end
       elsif immediate_operand? y_ref
         emit "imul #{register}, #{x_ref}, #{y_ref}\n"
-      else
-        emit "mov #{register}, #{x_ref}\n"
+      elsif y_ref != register
+        emit "mov #{register}, #{x_ref}\n" unless x_ref == register
         emit "imul #{register}, #{y_ref}\n"
+      else
+        emit "imul #{register}, #{x_ref}\n"
       end
     end
 
@@ -642,13 +614,44 @@ module Voodoo
     # Start a conditional using the specified branch instruction
     # after the comparison.
     def common_if branch, x, y = nil
-      load_value_into_register y, @DX if y
-      load_value_into_register x, @AX
+      # Inverses of branches. E.g.
+      #   cmp x, y
+      #   jle somewhere
+      # is the same as
+      #   cmp y, x
+      #   jgt somewhere
+      inverse_branch = {
+        :je => :je,
+        :jge => :jl,
+        :jg => :jle,
+        :jl => :jge,
+        :jle => :jg,
+        :jne => :jne,
+      }
+
+      y_ref = load_value y, @DX
+      x_ref = load_value x, @AX
+      if immediate_operand?(x_ref)
+        # Can't have an immediate value as the first operand.
+        if immediate_operand?(y_ref)
+          # Both are immediates. Put the first in a register.
+          emit "mov #{@AX}, #{x_ref}\n"
+          x_ref = @AX
+        else
+          # y isn't immediate; swap x and y.
+          x_ref, y_ref = [y_ref, x_ref]
+          branch = inverse_branch[branch]
+        end
+      elsif memory_operand?(x_ref) && memory_operand?(y_ref)
+        # Can't have two memory operands. Move the first into a register.
+        emit "mov #{@AX}, #{x_ref}\n"
+        x_ref = @AX
+      end
       truelabel = @environment.gensym
       falselabel = @environment.gensym
       @if_labels.push falselabel
 
-      emit "cmp #{@AX}, #{@DX}\n"
+      emit "cmp #{@WORD_NAME} #{x_ref}, #{y_ref}\n"
       emit "#{branch} #{truelabel}\n"
       emit "jmp #{falselabel}\n"
       emit "#{truelabel}:\n"
@@ -662,7 +665,6 @@ module Voodoo
 
     # Start the false path of a conditional.
     def ifelse
-      emit "; else\n"
       newlabel = @environment.gensym
       emit "jmp #{newlabel}\n"
       label = @if_labels.pop
@@ -672,38 +674,32 @@ module Voodoo
 
     # Test if x is equal to y
     def ifeq x, y
-      emit "; ifeq #{x} #{y}\n"
-      common_if 'je', x, y
+      common_if :je, x, y
     end
 
     # Test if x is greater than or equal to y
     def ifge x, y
-      emit "; ifge #{x} #{y}\n"
-      common_if 'jge', x, y
+      common_if :jge, x, y
     end
 
     # Test if x is strictly greater than y
     def ifgt x, y
-      emit "; ifgt #{x} #{y}\n"
-      common_if 'jg', x, y
+      common_if :jg, x, y
     end
 
     # Test if x is less than or equal to y
     def ifle x, y
-      emit "; ifle #{x} #{y}\n"
-      common_if 'jle', x, y
+      common_if :jle, x, y
     end
 
     # Test if x is strictly less than y
     def iflt x, y
-      emit "; iflt #{x} #{y}\n"
-      common_if 'jl', x, y
+      common_if :jl, x, y
     end
 
     # Test if x different from y
     def ifne x, y
-      emit "; ifne #{x} #{y}\n"
-      common_if 'jne', x, y
+      common_if :jne, x, y
     end
 
     #
@@ -724,13 +720,19 @@ module Voodoo
 
     # Emit a comment
     def comment text
-      emit ";#{text}\n"
+      emit "; #{text}\n"
     end
 
-    # Load a value into a register
-    def load_value_into_register value, register
-      value_ref = load_value value, register
-      set_register register, value_ref
+    # Returns a memory reference for the address at the given offset
+    # from the frame pointer.
+    def offset_reference offset
+      if offset > 0
+        "[#{@BP} + #{offset}]"
+      elsif offset < 0
+        "[#{@BP} - #{-offset}]"
+      else
+        "[#{@BP}]"
+      end
     end
 
     # Set a register to a value.