voodoo 0.5.0

data/lib/voodoo/generators/amd64_nasm_generator.rb

@@ -0,0 +1,288 @@
+require 'voodoo/generators/nasm_generator'
+
+module Voodoo
+  # = AMD64 NASM Code Generator
+  #
+  # Code generator that emits NASM assembly code for AMD64 processors.
+  # 
+  # == Calling Convention
+  #
+  # The calling convention implemented by this code generator is
+  # compatible with the System V ABI for AMD64, provided that all
+  # arguments are integers or pointers.
+  #
+  # Arguments are passed in registers. The registers are used in the
+  # following order:
+  #
+  # 1. +rdi+
+  # 2. +rsi+
+  # 3. +rdx+
+  # 4. +rcx+
+  # 5. +r8+
+  # 6. +r9+
+  #
+  # Additional arguments are pushed on the stack, starting with the last
+  # argument and working backwards. These arguments are removed from the
+  # stack by the caller, after the called function returns.
+  #
+  # The return value is passed in +rax+.
+  #
+  # For varargs functions, +rax+ must be set to an upper bound on the
+  # number of vector arguments. Since the code generator does not know
+  # whether the called function is a varargs function, this is always
+  # done. Since the code generator never passes any vector arguments,
+  # this means +rax+ is set to +0+ before each call. 
+  #
+  # == Call Frames
+  #
+  #   arg_n
+  #   :
+  #   arg_7
+  #   arg_6
+  #   saved_rip
+  #   saved_rbp <-- rbp
+  #   arg_0
+  #   arg_1
+  #   :
+  #   arg_5
+  #   local_0
+  #   local_1
+  #   :
+  #   local_n   <-- rsp
+  #
+  class AMD64NasmGenerator < NasmGenerator
+    def initialize params = {}
+      # Number of bytes in a word
+      @WORDSIZE = 8
+      # Word name in NASM lingo
+      @WORD_NAME = 'qword'
+      # 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 = 'rax'
+      # Register used as scratch register
+      @SCRATCH_REG = 'r11'
+      # Registers used for argument passing
+      @ARG_REGS = ['rdi', 'rsi', 'rdx', 'rcx', 'r8', 'r9']
+      # Accumulator index
+      @AX = 'rax'
+      # Base index
+      @BX = 'rbx'
+      # Count index
+      @CX = 'rcx'
+      # Data index
+      @DX = 'rdx'
+      super params
+    end
+
+    #
+    # == Data Definition
+    #
+
+    # Define a machine word with the given value.
+    def word value
+      qword value
+    end
+
+    #
+    # == Functions
+    #
+
+    # Call a function.
+    def call func, *args
+      emit "; call #{func} #{args.join ' '}\n"
+      # First couple of arguments go in registers
+      register_args = args[0..number_of_register_arguments] || []
+      # Rest of arguments go on the stack
+      stack_args = args[number_of_register_arguments..-1] || []
+      emit "; register_args: #{register_args.inspect}\n"
+      emit "; stack_args: #{stack_args.inspect}\n"
+      # Push stack arguments
+      stack_args.reverse.each { |arg| push_qword arg }
+      # Load register arguments
+      register_args.each_with_index do |arg,i|
+        register = @ARG_REGS[i]
+        value_ref = load_value arg, register
+        if value_ref != register
+          emit "mov #{register}, #{value_ref}\n"
+        end
+      end
+      # Call function
+      value_ref = load_value func, @SCRATCH_REG
+      emit "xor rax, rax\n"
+      # If value_ref is a symbol, use PLT-relative addressing
+      if global?(func)
+        emit "call #{value_ref} wrt ..plt\n"
+      else
+        emit "call #{value_ref}\n"
+      end
+      # Clean up stack
+      unless stack_args.empty?
+        emit "add rsp, #{stack_args.length * @WORDSIZE}\n"
+      end
+    end
+
+    # Emit function prologue.
+    def emit_function_prologue formals = []
+      emit "push rbp\nmov rbp, rsp\n"
+      unless formals.empty?
+        register_args = formals[0...number_of_register_arguments]
+        register_args.each_with_index do |arg,i|
+          emit "push #{@ARG_REGS[i]}\n"
+        end
+      end
+    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 required number of stack words
+      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
+
+      # If any arguments are going to be overwritten before they are
+      # used, save them to new local variables and use those instead.
+      i = args.length - 1
+      while i >= -1
+        arg = (i >= 0) ? args[i] : func
+
+        if symbol?(arg)
+          x = @environment[arg]
+          if x && x[0] == :arg && x[1] < args.length && x[1] > i &&
+              (i >= 0 || func != args[x[1]])
+            # Save value
+            newsym = @environment.gensym
+            let newsym, arg
+            # Change reference
+            if i >= 0
+              args[i] = newsym
+            else
+              func = newsym
+            end
+          end
+        end
+        i = i - 1
+      end
+
+      # Set stack arguments
+      if args.length > number_of_register_arguments
+        (args.length - 1 .. number_of_register_arguments).each do |i|
+          arg = args[i]
+          
+          value_ref = load_value arg, @SCRATCH_REG
+          newarg_ref = load_arg i
+          # Elide code if source is same as destination
+          unless value_ref == newarg_ref
+            emit "mov #{@WORD_NAME} #{newarg_ref}, #{value_ref}\n"
+          end
+        end
+      end
+
+      # Set register arguments
+      if args.length > 0
+        number_of_register_arguments(args.length).times do |i|
+          register = @ARG_REGS[i]
+          load_value_into_register args[i], register
+        end
+      end
+
+      # Tail call
+      func_ref = load_value func, @BX
+      emit "leave\n"
+      set_register @AX, 0
+      # If func_ref is a symbol, use PLT-relative addressing
+      if global?(func)
+        emit "jmp #{func_ref} wrt ..plt\n"
+      else
+        emit "jmp #{func_ref}\n"
+      end
+    end
+
+    #
+    # == Loading Values
+    #
+
+    # Load the value of the nth argument
+    def load_arg n, reg = @SCRATCH_REG
+      if register_argument?(n)
+        # Arguments that were originally passed in a register
+        # are now below rbp
+        "[rbp - #{(n + 1) * @WORDSIZE}]"
+      else
+        # Arguments that were originally passed on the stack
+        # are now above rbp
+        "[rbp + #{(n + 1 - number_of_register_arguments) * @WORDSIZE}]"
+      end
+    end
+
+    # Load the value of the nth local variable
+    def load_local n, reg = @SCRATCH_REG
+      # If there current function has any arguments,
+      # local variables are offset by
+      # number_of_register_arguments(number_of_arguments)
+      # words.
+      offset = number_of_register_arguments(@environment.args) * @WORDSIZE
+      "[rbp - #{offset + (n + 1) * @WORDSIZE}]"
+    end
+
+    #
+    # == Variables
+    #
+
+    # Introduce a new local variable
+    def let symbol, *words
+      emit "; let #{symbol} #{words.join ' '}\n"
+      @environment.add_local symbol
+      eval_expr words, @RETURN_REG
+      emit "push #{@RETURN_REG}\n"
+    end
+
+    #
+    # == Miscellaneous
+    #
+
+    # Load a value and push it on the stack.
+    def push_qword value
+      value_ref = load_value value, @SCRATCH_REG
+      emit "push qword #{value_ref}\n"
+    end
+
+    # Calculate the number of register arguments,
+    # given the total number of arguments.
+    # If _n_ is +nil+, returns the maximum number of
+    # register arguments.
+    def number_of_register_arguments n = nil
+      if n.nil?
+        @ARG_REGS.length
+      else
+        [@ARG_REGS.length, n].min
+      end
+    end
+
+    # Calculate the number of stack arguments,
+    # given the total number of arguments.
+    def number_of_stack_arguments n
+      [0, n - number_of_register_arguments].max
+    end
+
+    # Tests if the nth argument is a register argument.
+    def register_argument? n
+      n < number_of_register_arguments
+    end
+
+  end
+
+  # Register class
+  Voodoo::CodeGenerator.register_generator AMD64NasmGenerator,
+                                           :architecture => :amd64,
+                                           :format => :nasm
+end

data/lib/voodoo/generators/command_postprocessor.rb

@@ -0,0 +1,30 @@
+require 'delegate'
+require 'tempfile'
+
+module Voodoo
+  # Utility functions for classes that use commands to postprocess
+  # generator output.
+  module CommandPostProcessor
+    module_function
+
+    # Encodes a string so that it is safe for use as a shell argument
+    def shell_encode string
+      '"' + string.gsub(/([\\`"$\n])/, "\\\\\\1") + '"'
+    end
+
+    # Creates a temporary file and returns its name
+    def tempfile extension, base = nil
+      base = self.class.name unless base
+      file = Tempfile.open(basename + extension)
+      name = file.path
+      file.close
+      name
+    end
+
+    # Writes the contents of the named file to an IO handle
+    def write_file_to_io filename, io
+      File.open(filename) { |file| io.write(file.read) }
+    end
+
+  end
+end

data/lib/voodoo/generators/common_code_generator.rb

@@ -0,0 +1,238 @@
+require 'voodoo/generators/generator_api1'
+
+module Voodoo
+  # Common base class for code generators.
+  #
+  # Code generators are expected to implement the following methods:
+  #
+  # - #new
+  # - #add
+  # - #add_function
+  # - #gensym
+  # - #output_file_name
+  # - #wordsize
+  # - #write
+  #
+  # This class contains base implementations of some of these methods,
+  # which can be used and/or overridden by subclasses.
+  #
+  # An example of how to use the code generators provided by this module
+  # is provided on the main page of the documentation of the Voodoo module.
+  #
+  class CommonCodeGenerator
+    # Provide compatibility with old API
+    include GeneratorApi1
+
+    # Initializes the code generator.
+    # _params_ shall be a hash containing parameters to the code generator,
+    # and shall at least contain the keys <tt>:architecture</tt> and
+    # <tt>:format</tt>, specifying the target architecture and output
+    # format, respectively.
+    def initialize params = {}
+      @architecture = params[:architecture] || Config.default_architecture
+      @format = params[:format] || Config.default_format
+      @sections = {}
+      @section_aliases = {}
+      # Default section aliases. Subclasses can start from scratch by
+      # doing @section_aliases = {}
+      section_alias :code, ".text"
+      section_alias :functions, :code
+      section_alias :data, ".data"
+      self.section = :code
+      @top_level = Environment.initial_environment
+      @environment = @top_level
+    end
+
+    # Adds code to the given section.
+    #
+    # Examples:
+    #   add :code, [:return, 0]
+    #   add :data, [:align], [:label, :xyzzy], [:word, 42]
+    #
+    # This method implements the required functionality in terms
+    # of the following methods, which must be implemented by subclasses:
+    #
+    # - #align
+    # - #byte
+    # - #call
+    # - #end_if
+    # - #export
+    # - #begin_function
+    # - #ifelse
+    # - #ifeq
+    # - #ifge
+    # - #ifgt
+    # - #ifle
+    # - #iflt
+    # - #ifne
+    # - #import
+    # - #label
+    # - #let
+    # - #ret
+    # - #set
+    # - #set_byte
+    # - #set_word
+    # - #string
+    # - #word
+    #
+    def add section, *code
+      in_section section do
+        code.each do |action|
+          keyword, args = action[0], action[1..-1]
+          case keyword
+          when :function
+            begin_function *args[0]
+            args[1..-1].each { |action| add section, action }
+            end_function
+          when :ifeq, :ifge, :ifgt, :ifle, :iflt, :ifne
+            truebody = action[2]
+            falsebody = action[3]
+            send keyword, action[1][0], action[1][1]
+            add section, *truebody
+            if falsebody && !falsebody.empty?
+              ifelse
+              add section, *falsebody
+            end
+            end_if
+          when :return
+            send :ret, *args
+          when :'set-word'
+            send :set_word, *args
+          when :'set-byte'
+            send :set_byte, *args
+          when :'tail-call'
+            send :tail_call, *args
+          else
+            send *action
+          end
+        end
+      end
+    end
+
+    # Add function.
+    #
+    # Parameters:
+    # [formals] an Array of formal parameter names
+    # [code] an Array of actions to be used as the function's body
+    #
+    # Example:
+    #   add_function [:n], [:return, :add, :n, 1]
+    def add_function formals, *code
+      add :functions, [:function, formals] + code
+    end
+
+    # Generate a new, unused symbol
+    def gensym
+      Environment.gensym
+    end
+
+    # Add code to the current section
+    def emit code
+      @sections[real_section_name(@section)] << code
+    end
+
+    # Get the real name of a section.
+    # Given a section name which may be an alias, this method returns the
+    # real name of the section.
+    def real_section_name name
+      given_name = name
+      while true
+        x = @section_aliases[name]
+        break if x == nil       # Not an alias, exit loop and return name
+        name = x
+        # If name == given_name, we're back where we started. Continuing
+        # would have us loop forever. Just return what we have now.
+        break if name == given_name
+      end
+      name
+    end
+
+    # Set the current section
+    def section= name
+      real_name = real_section_name name
+      @section = name
+      unless @sections.has_key? real_name
+        @sections[real_name] = ''
+      end
+    end
+
+    def section name = nil
+      self.section = name if name
+      @section
+    end
+
+    # Set up +alias_name+ to refer to the same section as +original_name+.
+    def section_alias alias_name, original_name
+      @section_aliases[alias_name] = original_name
+    end
+
+    def in_section name, &block
+      oldsection = @section
+      self.section = name
+      begin
+        yield
+      ensure
+        self.section = oldsection
+      end
+    end
+
+    # Given an input file name, returns the canonical output file name
+    # for this code generator.
+    def output_file_name input_name
+      input_name.sub(/\.voo$/, '') + '.o'
+    end
+
+    class Environment
+      @@gensym_counter = 0
+
+      attr_reader :args, :locals, :symbols
+
+      def initialize parent = nil
+        ## Parent environment
+        @parent = parent
+        ## Symbol lookup table
+        @symbols = parent ? parent.symbols.dup : {}
+        ## Number of arguments
+        @args = parent ? parent.args : 0
+        ## Number of local variables
+        @locals = parent ? parent.locals : 0
+      end
+
+      def add_arg symbol
+        @symbols[symbol] = [:arg, @args]
+        @args = @args + 1
+      end
+
+      def add_args symbols
+        symbols.each { |sym| add_arg sym }
+      end
+
+      def add_local symbol
+        @symbols[symbol] = [:local, @locals]
+        @locals = @locals + 1
+      end
+
+      def add_locals symbols
+        symbols.each { |sym| add_local sym }
+      end
+
+      def gensym
+        Environment.gensym
+      end
+
+      def [] symbol
+        @symbols[symbol]
+      end
+
+      def self.gensym
+        @@gensym_counter = @@gensym_counter + 1
+        "_G#{@@gensym_counter}".to_sym
+      end
+
+      def self.initial_environment
+        Environment.new
+      end
+    end
+
+  end
+end