voodoo 0.5.0

data/lib/voodoo/generators/gas_generator.rb

@@ -0,0 +1,91 @@
+require 'voodoo/generators/common_code_generator'
+
+module Voodoo
+  # Common base class for code generators that target the GNU assembler
+  class GasGenerator < CommonCodeGenerator
+    def initialize params
+      super params
+    end
+
+    #
+    # == Alignment
+    #
+
+    # Align data on the next _alignment_-byte boundary.
+    # If _alignment_ is not specified, the default data alignment
+    # is used.
+    def align_data alignment = @DATA_ALIGNMENT
+      in_section(:data) { emit ".align #{alignment}" }
+    end
+
+    # Align code on the next _alignment_-byte boundary.
+    # If _alignment_ is not specified, the default code alignment
+    # is used.
+    def align_code alignment = @CODE_ALIGNMENT
+      in_section(:code) { emit ".align #{alignment}" }
+    end
+
+    # Align function on the next _alignment_-byte boundary.
+    # If _alignment_ is not specified, the default function alignment
+    # is used.
+    def align_function alignment = @FUNCTION_ALIGNMENT
+      in_section(:code) { emit ".align #{alignment}" }
+    end
+
+    #
+    # == Data Definition
+    # 
+
+    # Define a byte with the given value
+    def byte value
+      emit ".byte #{value}\n"
+    end
+
+    # Define a string with the given value
+    def string value
+      code = ''
+      value.each_byte do |b|
+        if b >= 32 && b < 128
+          code << b.chr
+        else
+          code << sprintf('\%02x', b)
+        end
+      end
+      emit ".ascii \"#{code}\"\n"
+    end
+
+    # Define a machine word with the given value
+    def word value
+      emit ".word #{value}\n"
+    end
+
+    #
+    # == Information About the Generator
+    #
+
+    # Returns the number of bits per word for this code generator.
+    def wordsize
+      @WORDSIZE * 8
+    end
+
+    #
+    # == Labels
+    #
+
+    # Export symbols from the current section
+    def export *symbols
+      symbols.each { |sym| emit ".globl #{sym}\n" }
+    end
+
+    # Import labels into the current section
+    def import *symbols
+      # nothing
+    end
+
+    # Define a label in the current section
+    def label name
+      emit "#{name}:\n"
+    end
+
+  end
+end

data/lib/voodoo/generators/generator_api1.rb

@@ -0,0 +1,95 @@
+module Voodoo
+  # This module implements the old code generation API, consisting of
+  # the following methods:
+  #
+  # #add_code
+  # #add_code_label
+  # #add_data
+  # #add_data_label
+  # #add_function
+  # #add_function_label
+  # #align_code
+  # #align_data
+  # #align_function
+  #
+  module GeneratorApi1
+    # Add code.
+    #
+    # Parameters:
+    # [actions] an Array of actions to be added
+    #
+    # Example:
+    #   add_code [:call, :exit, 0]
+    def add_code *actions
+      add :code, *actions
+    end
+
+    # Add a label at the current address in the code section.
+    #
+    # Example:
+    #   add_code_label :mylabel
+    def add_code_label name
+      in_section(:code) { label name }
+    end
+
+    # Add data.
+    #
+    # Parameters:
+    # [defs] an Array of data definitions
+    #
+    # Example:
+    #   add_data [:word, 42]
+    def add_data *defs
+      add :data, *defs
+    end
+
+    # Add a label at the current address in the data section.
+    #
+    # Example:
+    #   add_data_label :msg
+    def add_data_label name
+      add :data, [:label, name]
+    end
+
+    # Add a label at the address where the next function will be generated.
+    #
+    # Example:
+    #   add_function_label :add_one
+    def add_function_label name
+      add :functions, [:label, name]
+    end
+
+    # Align code on the next _alignment_-byte boundary.
+    # If _alignment_ is not specified, the default code alignment
+    # is used.
+    def align_code alignment = nil
+      if alignment
+        add :code, [:align, alignment]
+      else
+        add :code, [:align]
+      end
+    end
+
+    # Align data on the next _alignment_-byte boundary.
+    # If _alignment_ is not specified, the default data alignment
+    # is used.
+    def align_data alignment = nil
+      if alignment
+        add :data, [:align, alignment]
+      else
+        add :data, [:align]
+      end
+    end
+
+    # Align function on the next _alignment_-byte boundary.
+    # If _alignment_ is not specified, the default function alignment
+    # is used.
+    def align_function alignment = nil
+      if alignment
+        add :functions, [:align, alignment]
+      else
+        add :functions, [:align]
+      end
+    end
+  end
+end

data/lib/voodoo/generators/i386_elf_generator.rb

@@ -0,0 +1,62 @@
+require 'delegate'
+require 'tempfile'
+require 'voodoo/config'
+require 'voodoo/generators/i386_nasm_generator'
+
+module Voodoo
+  # Generator that produces ELF objects
+  class I386ELFGenerator < DelegateClass(I386NasmGenerator)
+    def initialize params = {}
+      @nasmgenerator = I386NasmGenerator.new params
+      super(@nasmgenerator)
+    end
+
+    def output_file_name input_name
+      input_name.sub(/\.voo$/, '') + '.o'
+    end
+
+    # Encodes a string so that it is safe for use as a shell argument
+    def shell_encode string
+      '"' + string.gsub(/([\\`"$\n])/, "\\\\\\1") + '"'
+    end
+
+    # Writes the generated code to the given IO handle
+    def write io
+      # Create temporary file to write NASM code to
+      if io.respond_to? :path
+        basename = File.basename(io.path).sub(/([^.]*).*/, "\\1")
+      else
+        basename = self.class.name
+      end
+      Tempfile.open(basename + '.asm') do |nasmfile|
+        Tempfile.open(basename + '.o') do |elffile|
+          elffile.close
+          @nasmgenerator.write nasmfile
+          nasmfile.close
+          # Invoke nasm on nasmfile
+          if ENV.has_key? 'NASM'
+            nasm = ENV['NASM']
+          elsif ENV.has_key? 'YASM'
+            nasm = ENV['YASM']
+          else
+            nasm = Config.nasm_command
+          end
+          command = "#{nasm} -f elf -o #{shell_encode elffile.path}" +
+            " #{shell_encode nasmfile.path}"
+          if system(command)
+            File.open(elffile.path) do |file|
+              io.write file.read
+            end
+          end
+          elffile.unlink
+        end
+        nasmfile.unlink
+      end
+    end
+  end
+
+  # Register class
+  Voodoo::CodeGenerator.register_generator I386ELFGenerator,
+                                           :architecture => :i386,
+                                           :format => :elf
+end

data/lib/voodoo/generators/i386_nasm_generator.rb

@@ -0,0 +1,177 @@
+require 'voodoo/generators/common_code_generator'
+
+module Voodoo
+  # = i386 NASM Code Generator
+  #
+  # The i386 NASM code generator generates i386 assembly code for use with
+  # the {Netwide Assembler}[http://www.nasm.us/].
+  #
+  # == Calling Convention
+  #
+  # Function arguments are pushed on the stack in reverse order, so that
+  # the first argument is pushed last. Each argument occupies one word
+  # of stack space. These arguments are removed from the stack by the
+  # caller after the called function returns.
+  #
+  # The return value is passed in +eax+.
+  #
+  # == Call Frames
+  #
+  # Call frames have the following layout:
+  #
+  #   argn
+  #   :
+  #   arg1
+  #   arg0   <-- ebp + 8
+  #   oldeip <-- ebp + 4
+  #   oldebp <-- ebp
+  #   local0 <-- ebp - 4
+  #   local1 <-- ebp - 8
+  #   :
+  #   localn <-- esp
+  #
+  class I386NasmGenerator < NasmGenerator
+    WORDSIZE = 4
+
+    def initialize params = {}
+      # Number of bytes in a word
+      @WORDSIZE = 4
+      # Word name in NASM lingo
+      @WORD_NAME = 'dword'
+      # Default alignment for code
+      @CODE_ALIGNMENT = 0
+      # Default alignment for data
+      @DATA_ALIGNMENT = @WORDSIZE
+      # Default alignment for functions
+      @FUNCTION_ALIGNMENT = 16
+      # Register used for return values
+      @RETURN_REG = 'eax'
+      # Register used as scratch register
+      @SCRATCH_REG = 'ebx'
+      # Accumulator index
+      @AX = 'eax'
+      # Base index
+      @BX = 'ebx'
+      # Count index
+      @CX = 'ecx'
+      # Data index
+      @DX = 'edx'
+      super params
+    end
+
+    # Call 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"
+      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}]"
+    end
+
+    # Load the value of the nth local variable
+    def load_local n, reg = @SCRATCH_REG
+      "[ebp - #{(n + 1) * @WORDSIZE}]"
+    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"
+    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 fram 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
+          end
+          i = i - 1
+        end
+
+        # Set arguments
+        if args.length > 0
+          (args.length - 1 .. 0).each do |i|
+            arg = args[i]
+            
+            value_ref = load_value arg, "eax"
+            newarg_ref = "[ebp + #{(i + 2) * WORDSIZE}]"
+            # 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"
+              end
+              emit "mov #{@WORD_NAME} [ebp + #{(i + 2) * WORDSIZE}], " +
+                    "#{value_ref}\n"
+            end
+          end
+        end
+
+        # Tail call
+        emit "mov esp, ebp\npop ebp\n"
+        use_value "jmp", fun
+      end
+    end
+
+    def use_value operation, value
+      value_ref = load_value value, "eax"
+      emit "#{operation} #{value_ref}\n"
+    end
+
+    # Define a machine word with the given value
+    def word value
+      emit "dd #{value}\n"
+    end
+
+  end
+
+  # Register class
+  Voodoo::CodeGenerator.register_generator I386NasmGenerator,
+                                           :architecture => :i386,
+                                           :format => :nasm
+end

data/lib/voodoo/generators/mips_gas_generator.rb

@@ -0,0 +1,148 @@
+require 'voodoo/generators/gas_generator'
+
+module Voodoo
+  # = MIPS GNU Assembler Code Generator
+  #
+  # The MIPS code generator generates i386 assembly code for use with
+  # the GNU assembler.
+  #
+  # == Calling Convention
+  #
+  # The first four arguments are passed in the registers $4 through $7.
+  # Any additional arguments are passed in registers.
+  #
+  # The return value is passed in $2.
+  #
+  # This calling convention is compatible with the System V ELF ABI.
+  #
+  # == 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
+  #   argn
+  #   :
+  #   arg4
+  #   empty3
+  #   empty2
+  #   empty1
+  #   empty0    <-- $sp points here
+  #
+  # Where $sp is $29, and must be a multiple of 8.
+  #
+  # TODO: Description of how we organize things below the original frame.
+  # FIXME: Following is just a sketch and is likely neither complete nor
+  # correct.
+  # See the ELF ABI for MIPS, Standard Called Function Rules.
+  #
+  #   1. Adjust $sp to create new stack frame
+  #      - Need space to save $sp, $r, and however many local variables
+  #        the function uses
+  #      - $sp must be a multiple of 8
+  #   2. Calculate $gp (TODO: how?) and save it somewhere (either on the stack
+  #      or in a previously-saved callee-save register)
+  #   3. Save $sp and $r
+  #
+  # Note that, to comply with the standard called function rules laid out
+  # in the System V ABI, a function can only have one exit. Thus, early
+  # returns will have to be translated to gotos to the single exit.
+  #
+  #   saved_r
+  #   saved_sp
+  #   :
+  #   local8
+  #   :
+  #   localn    <-- $sp points here
+  #
+  # Register $0 is always 0.
+  #
+  # Registers $8 through $15 and register $24 are used as temporaries.
+  #
+  # Registers $16 through $23 and register $30 are used for local
+  # variables. They are callee-save, which means the value they had upon
+  # function entry must be restored before returning.
+  #
+  # Register $25 is used to hold the address of the called function when
+  # position-independent code is called. Otherwise, it may be used as
+  # a temporary.
+  #
+  # Registers $26 and $27 are reserved for operating system use.
+  #
+  # Register $28 is used as global pointer (FIXME: what does this mean?)
+  #
+  # Register $29 is used as stack pointer. It is callee-save: the
+  # value it has upon function entry must be restored before returning.
+  # The stack pointer must always be a multiple of 8.
+  #
+  # Register $31 is used to store the return address when calling a function.
+  #
+  module MIPSGasGenerator
+    def initialize params
+      @WORDSIZE = 4
+      @CODE_ALIGNMENT = 0
+      @DATA_ALIGNMENT = @WORDSIZE
+      @FUNCTION_ALIGNMENT = @WORDSIZE
+      super params
+    end
+
+    #
+    # == Functions
+    #
+
+    # Emit function prologue 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
+
+    # Call a function.
+    def call func, *args
+      raise 'TODO'
+    end
+
+    # Emit function epilogue.
+    def emit_function_epilogue formals = []
+      raise 'TODO'
+    end
+
+    # Emit function prologue.
+    def emit_function_prologue formals = []
+      raise 'TODO'
+    end
+
+    # End 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
+        @environment = @top_level
+      end
+    end
+
+    # Call a function, re-using the current call frame if possible.
+    def tail_call func, *args
+      raise 'TODO'
+    end
+
+    # Return a 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
+      emit_function_epilogue
+      emit "j	$31\n"
+    end
+
+    
+  end
+end