voodoo 0.6.3 → 0.7.0

data/lib/voodoo/generators/amd64_nasm_generator.rb

@@ -76,6 +76,10 @@ module Voodoo
       @CX = 'rcx'
       # Data index
       @DX = 'rdx'
+      # Base pointer
+      @BP = 'rbp'
+      # Stack pointer
+      @SP = 'rsp'
       super params
     end
 

data/lib/voodoo/generators/common_code_generator.rb

@@ -55,11 +55,14 @@ module Voodoo
     # of the following methods, which must be implemented by subclasses:
     #
     # - #align
+    # - #asr
+    # - #bsr
     # - #byte
     # - #call
     # - #end_if
     # - #export
     # - #begin_function
+    # - #block
     # - #ifelse
     # - #ifeq
     # - #ifge
@@ -71,9 +74,13 @@ module Voodoo
     # - #label
     # - #let
     # - #ret
+    # - #rol
+    # - #ror
     # - #set
     # - #set_byte
     # - #set_word
+    # - #shl
+    # - #shr
     # - #string
     # - #word
     #
@@ -82,6 +89,8 @@ module Voodoo
         code.each do |action|
           keyword, args = action[0], action[1..-1]
           case keyword
+          when :block
+            block *args
           when :function
             function args[0], *args[1..-1]
           when :ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne
@@ -121,6 +130,34 @@ module Voodoo
       add :functions, [:function, formals] + code
     end
 
+    # Processes code in its own block. Local variables can be
+    # introduced inside the block. They will be deleted at the
+    # end of the block.
+    def block *code
+      begin_block *code
+      code.each { |action| add section, action }
+      end_block
+    end
+
+    # Invokes block with each statement in the given list of statements.
+    # This iterator also descends into nested statements, calling
+    # block first with the outer statement, and then for each inner
+    # statement.
+    def each_statement statements, &block
+      statements.each do |statement|
+        yield statement
+        case statement[0]
+        when :block
+          each_statement statement[1..-1], &block
+        when :function
+          each_statement statement[2..-1], &block
+        when :ifeq, :ifle, :iflt, :ifge, :ifgt, :ifne
+          each_statement statement[2], &block
+          each_statement(statement[3], &block) if statement.length > 3
+        end
+      end
+    end
+
     # Add a function to the current section
     def function formals, *code
       begin_function *formals
@@ -197,8 +234,11 @@ module Voodoo
     class Environment
       @@gensym_counter = 0
 
-      attr_reader :args, :locals, :symbols
+      attr_reader :args, :locals, :parent, :symbols
 
+      # Creates a new environment.
+      # If parent is specified, it will become the new environment's parent.
+      # The new environment inherits all symbols from the parent environment.
       def initialize parent = nil
         ## Parent environment
         @parent = parent
@@ -210,37 +250,47 @@ module Voodoo
         @locals = parent ? parent.locals : 0
       end
 
+      # Adds symbol as an argument in this environment.
       def add_arg symbol
         @symbols[symbol] = [:arg, @args]
         @args = @args + 1
       end
 
+      # Adds each of symbols to the arguments in
+      # this environment.
       def add_args symbols
         symbols.each { |sym| add_arg sym }
       end
 
+      # Adds symbol as a local variable in this environment.
       def add_local symbol
         @symbols[symbol] = [:local, @locals]
         @locals = @locals + 1
       end
 
+      # Adds each of symbols to the local variables in
+      # this environment.
       def add_locals symbols
         symbols.each { |sym| add_local sym }
       end
 
+      # Generates a new, unique symbol.
       def gensym
         Environment.gensym
       end
 
+      # Looks up symbol in this environment.
       def [] symbol
         @symbols[symbol]
       end
 
+      # Generates a new, unique symbol.
       def self.gensym
         @@gensym_counter = @@gensym_counter + 1
         "_G#{@@gensym_counter}".to_sym
       end
 
+      # Returns an initial, top-level environment.
       def self.initial_environment
         Environment.new
       end

data/lib/voodoo/generators/i386_nasm_generator.rb

@@ -56,6 +56,10 @@ module Voodoo
       @CX = 'ecx'
       # Data index
       @DX = 'edx'
+      # Base pointer
+      @BP = 'ebp'
+      # Stack pointer
+      @SP = 'esp'
       super params
     end
 

data/lib/voodoo/generators/mips_gas_generator.rb

@@ -160,7 +160,7 @@ module Voodoo
 
     # Test if op is a binary operation
     def assymetric_binop? op
-      [:div, :mod, :sub].member?(op)
+      [:asr, :bsr, :div, :mod, :rol, :ror, :shl, :shr, :sub].member?(op)
     end
 
     # Test if a value is an at-expression
@@ -168,6 +168,17 @@ module Voodoo
       value.respond_to?(:[]) && value[0] == :'@'
     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)
+      end
+      environment = Environment.new @environment
+      @environment = environment
+    end
+
     # Emit function prologue and declare _formals_ as function arguments
     def begin_function formals, nlocals
       if @environment != @top_level
@@ -282,6 +293,25 @@ 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
+    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"
+    end
+
     # Emit function prologue.
     def emit_function_prologue formals = [], nlocals = 0
       # Calculate new value for $gp
@@ -295,9 +325,7 @@ module Voodoo
         emit "sw $#{n + @REGISTER_ARG_BASE}, #{n * @WORDSIZE}($29)\n"
       end
 
-      # Create initial frame
-      @frame_size = (@INITIAL_FRAME_SIZE + nlocals * @WORDSIZE + 7) / 8 * 8
-      emit "addiu $sp, $sp, -#{@frame_size}\n"
+      create_frame nlocals
 
       # Save return address
       emit "sw $31, #{@frame_size - @WORDSIZE}($sp)\n"
@@ -333,6 +361,19 @@ module Voodoo
       @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"
+      end
+
+      # Restore old value of @environment
+      @environment = @environment.parent
+    end
+
     # End a conditional.
     def end_if
       label = @if_labels.pop
@@ -348,6 +389,10 @@ module Voodoo
       temporaries.delete y
 
       case expr[0]
+      when :asr
+        emit "srav #{register}, #{x}, #{y}\n"
+      when :bsr
+        emit "srlv #{register}, #{x}, #{y}\n"
       when :div
         emit "div $0, #{x}, #{y}\n"
         emit "mflo #{register}\n"
@@ -357,6 +402,20 @@ module Voodoo
       when :mul
         emit "mult #{x}, #{y}\n"
         emit "mflo #{register}\n"
+      when :rol
+        emit "subu #{@TEMPORARY}, $0, #{y}\n"
+        emit "srlv #{@TEMPORARY}, #{x}, #{@TEMPORARY}\n"
+        emit "sllv #{register}, #{x}, #{y}\n"
+        emit "or #{register}, #{register}, #{@TEMPORARY}\n"
+      when :ror
+        emit "subu #{@TEMPORARY}, $0, #{y}\n"
+        emit "sllv #{@TEMPORARY}, #{x}, #{@TEMPORARY}\n"
+        emit "srlv #{register}, #{x}, #{y}\n"
+        emit "or #{register}, #{register}, #{@TEMPORARY}\n"
+      when :shl
+        emit "sllv #{register}, #{x}, #{y}\n"
+      when :shr
+        emit "srlv #{register}, #{x}, #{y}\n"
       else
         emit "#{expr[0]} #{register}, #{x}, #{y}\n"
       end
@@ -397,9 +456,7 @@ module Voodoo
 
     # Add a function to the current section
     def function formals, *code
-      # Set nlocals to the number of local variables in the function
-      nlocals = 0
-      code.each { |action| nlocals = nlocals + 1 if action[0] == :let }
+      nlocals = count_locals code
       begin_function formals, nlocals
       code.each { |action| add section, action }
       end_function
@@ -514,9 +571,13 @@ module Voodoo
       n = @environment.locals
       @environment.add_local symbol
 
-      # Extend stack frame, if necessary
+      # 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
@@ -525,11 +586,13 @@ module Voodoo
       register = local_register n
       ref = local_reference n
       if register
+        # We will use a register to store the value
         # Save current value of register
         emit "sw #{register}, #{ref}\n"
         # Set new value
         eval_expr expr, register
       else
+        # We will use the stack to store the value
         eval_expr expr, @TEMPORARY
         emit "sw #{@TEMPORARY}, #{ref}\n"
       end
@@ -651,7 +714,7 @@ module Voodoo
     def ret *words
       emit "# return #{words.join ' '}\n"
       # Compute return value and store it in @RETURN
-      eval_expr words, @RETURN
+      eval_expr(words, @RETURN) unless words.empty?
       # Go to epilogue
       goto @function_end_label
     end

data/lib/voodoo/generators/nasm_generator.rb

@@ -21,7 +21,7 @@ module Voodoo
   # - @SCRATCH_REG
   # - @WORD_NAME
   # - @WORDSIZE
-  # - @AX, @BX, @CX, and @DX
+  # - @AX, @BX, @CX, @DX, @BP, and @SP
   class NasmGenerator < CommonCodeGenerator
     def initialize params = {}
       super params
@@ -166,11 +166,43 @@ module Voodoo
     # of the evaluation is returned from the function.
     def ret *words
       emit "; return #{words.join ' '}\n"
-      eval_expr words
+      eval_expr(words) unless words.empty?
       emit_function_epilogue
       emit "ret\n"
     end
 
+    #
+    # == Blocks
+    #
+
+    # 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
+        emit "push #{@BP}\n"
+        emit "mov #{@BP}, #{@SP}\n"
+      end
+      environment = Environment.new @environment
+      @environment = environment
+    end
+
+    # 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
+    end
+
     #
     # == Conditionals
     #
@@ -192,7 +224,8 @@ module Voodoo
 
     # Test if op is a binary operation
     def binop? op
-      [:div, :mod, :sub].member?(op) || symmetric_operation?(op)
+      [:asr, :bsr, :div, :mod, :rol, :ror, :shl, :shr, :sub].member?(op) ||
+        symmetric_operation?(op)
     end
 
     # Test if a value is an integer
@@ -416,18 +449,24 @@ module Voodoo
         return mod(target, x, y) if op == :mod
         return mul(target, x, y) if op == :mul
 
-        target_ref = load_value target, @AX
+        target_ref = load_value target, @BX
         x_ref = load_value x, @DX
-        y_ref = load_value y, @BX
+        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 #{@CX}, #{x_ref}\n"
-            emit "#{op} #{@CX}, #{y_ref}\n"
-            emit "mov #{target_ref}, #{@CX}\n"
+            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 "#{op} #{@WORD_NAME} #{target_ref}, #{y_ref}\n"
+            emit "#{mnemonic} #{@WORD_NAME} #{target_ref}, #{y_ref}\n"
           end
         else
           raise "Can't happen: target_ref is #{target_ref.inspect}"
@@ -443,13 +482,17 @@ module Voodoo
       return mod2(target, y) if op == :mod
       return mul2(target, y) if op == :mul
 
-      target_ref = load_value target, @BX
-      y_ref = load_value y, @DX
-      if memory_operand?(target_ref) && memory_operand?(y_ref)
-        emit "mov #{@AX}, #{y_ref}\n"
-        emit "#{op} #{target_ref}, #{@AX}\n"
+      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 "#{op} #{@WORD_NAME} #{target_ref}, #{y_ref}\n"
+        emit "#{mnemonic} #{@WORD_NAME} #{target_ref}, #{y_ref}\n"
       end
     end
 
@@ -510,6 +553,7 @@ module Voodoo
 
     # Evaluate an expression.
     # The result is stored in _register_ (@RETURN_REG by default).
+    # The following registers may be clobbered: @AX, @BX, @CX, @DX
     def eval_expr words, register = @RETURN_REG
       if words.length == 1
         if words[0] == 0
@@ -520,6 +564,10 @@ module Voodoo
       else
         op = words[0]
         case op
+        when :asr, :bsr, :rol, :ror, :shl, :shr
+          load_value_into_register words[2], @CX
+          load_value_into_register words[1], register
+          emit "#{action_to_mnemonic op} #{register}, cl\n"
         when :call
           call *words[1..-1]
         when :div
@@ -666,6 +714,18 @@ module Voodoo
     # == Miscellaneous
     #
 
+    # Translates a Voodoo action name to an x86 mnemonic
+    def action_to_mnemonic action
+      case action
+      when :asr
+        :sar
+      when :bsr
+        :shr
+      else
+        action
+      end
+    end
+
     # Emit a comment
     def comment text
       emit ";#{text}\n"

data/lib/voodoo/parser.rb

@@ -139,16 +139,10 @@ module Voodoo
         body = parse_body :function
         [:function, words[1..-1], body]
       elsif is_conditional?(words[0])
-        # Conditional. Parse true part
-        true_body = parse_body :conditional
-        # Parse false part, if present
-        if true_body[-1] == :else
-          true_body = true_body[0..-2]
-          false_body = parse_body :conditional
-        else
-          false_body = []
-        end
-        [words[0], words[1..-1], true_body, false_body]
+        parse_conditional1 words[0], words[1..-1]
+      elsif words[0] == :block
+        body = parse_body :block
+        [:block] + body
       else
         # Statement or data declaration; simply return it
         words
@@ -173,7 +167,7 @@ module Voodoo
           break
         elsif kind == :conditional && statement[0] == :else
           # Done parsing body, but there is another one coming up
-          body << :else
+          body << statement
           break
         else
           # Parsed a statement. Add it to body.
@@ -293,6 +287,53 @@ module Voodoo
     def is_conditional? symbol
       [:ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne].member? symbol
     end
-  end
 
+    #
+    # Private methods
+    #
+    private
+
+    # Parses a conditional statement
+    def parse_conditional1 condition, operands
+      # Parse first clause and condition for next clause
+      consequent, next_condition = split_if_clause parse_body(:conditional)
+      if next_condition == nil
+        # No next clause
+        alternative = []
+      elsif next_condition == :else
+        # Next clause is else without if
+        alternative = parse_body :conditional
+      else
+        # Next clause is else with if
+        alternative = [parse_conditional1(next_condition[0],
+                                          next_condition[1])]
+      end
+      [condition, operands, consequent, alternative]
+    end
+
+    # Splits a parsed if-clause into two parts:
+    # 1. The list of statements making up the clause proper
+    # 2. The condition for the next clause:
+    #    - If there is no next clause, nil
+    #    - If the next clause is introduced by else without a condition, :else
+    #    - If the next clause is introduced by else iflt x y, [:iflt [:x, :y]]
+    #    - And so on for other if.. instances
+    def split_if_clause clause
+      last = clause[-1]
+      if last.respond_to?(:[]) && last.length > 0 && last[0] == :else
+        clause = clause[0..-2]
+        if last.length > 1
+          # Else if
+          [clause, [last[1], last[2..-1]]]
+        else
+          # Only else
+          [clause, :else]
+        end
+      else
+        # No else
+        [clause, nil]
+      end
+    end
+
+  end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: voodoo
 version: !ruby/object:Gem::Version 
-  hash: 1
+  hash: 3
   prerelease: false
   segments: 
   - 0
-  - 6
-  - 3
-  version: 0.6.3
+  - 7
+  - 0
+  version: 0.7.0
 platform: ruby
 authors: 
 - Robbert Haarman
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-21 00:00:00 +01:00
+date: 2011-01-15 00:00:00 +01:00
 default_executable: 
 dependencies: []