Added support for div, mod, and mul to amd64 code generator.

[voodoo-lang.git] / lib / ruby / voodoo / generators / nasm_generator.rb

require 'voodoo/generators/common_code_generator'

module Voodoo
  # Mixin for code generators that target NASM
  #
  # Requires the following methods and constants:
  # - #emit
  # - #emit_function_prologue
  # - #load_arg
  # - #load_local
  # - @CODE_ALIGNMENT
  # - @DATA_ALIGNMENT
  # - @FUNCTION_ALIGNMENT
  # - @SCRATCH_REG
  class NasmGenerator < CommonCodeGenerator

    #
    # == Labels
    #

    # Export symbols from the current section
    def export *symbols
      emit "global #{symbols.join ', '}\n"
    end

    # Import labels into the current section
    def import *symbols
      emit "extern #{symbols.join ', '}\n"
    end

    # Define a label in the current section
    def label name
      emit "#{name}:\n"
    end

    #
    # == Data definition
    #

    # Define a byte with the given value
    def byte value
      emit "db #{value}\n"
    end

    # Define a dword with the given value
    def dword value
      emit "dd #{value}\n"
    end

    # Define a qword with the given value
    def qword value
      emit "dq #{value}\n"
    end

    # Define a string with the given value
    def string value
      code = ''
      in_quote = false
      value.each_byte do |b|
        if b >= 32 && b < 128
          if in_quote
            code << b.chr
          else
            code << "'" + b.chr
            in_quote = true
          end
        else
          if in_quote
            code << "',#{b}"
            in_quote = false
          else
            code << ",#{b}"
          end
        end
      end
      emit "db #{code}\n"
    end

    #
    # == Alignment
    #

    def align_data alignment = @DATA_ALIGNMENT
      in_section(:data) { emit "align #{alignment},db 0" }
    end

    def align_code alignment = @CODE_ALIGNMENT
      in_section(:code) { emit "align #{alignment},nop" }
    end

    def align_function alignment = @FUNCTION_ALIGNMENT
      in_section(:code) { emit "align #{alignment},nop" }
    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

    # 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

    #
    # == Conditionals
    #

    # End a conditional body
    def end_if
      label = @if_labels.pop
      emit "#{label}:\n"
    end

    #
    # == Value Classification
    #

    # Test if op is a binary operation
    def binop? op
      [:div, :mod, :sub].member?(op) || symmetric_operation?(op)
    end

    # Test if a value is an integer
    def integer? value
      value.kind_of? Integer
    end

    # Test if a symbol refers to a global
    def global? symbol
      symbol?(symbol) && @environment[symbol] == nil
    end

    # Tests if an operand is an immediate operand
    def immediate_operand? operand
      integer?(operand) || global?(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
    end

    #
    # == Loading Values
    #

    # 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
      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
      else
        # Assume global
        symbol
      end
    end
    
    # Load a value.
    # Returns a string that can be used to refer to the loaded value.
    def load_value value, reg = @SCRATCH_REG
      if integer? value
        # Integers can be used as is
        value
      elsif symbol? value
        load_symbol value, reg
      end
    end

    #
    # == Miscellaneous
    #

    # Emit a comment
    def comment text
      emit ";#{text}\n"
    end

    #
    # == Output
    #

    # Write generated code to the given IO object.
    def write io
      io.puts "bits #{@WORDSIZE * 8}\n\n"
      @sections.each do |section,code|
        unless code.empty?
          case section
          when :code
            section_name = '.text'
          when :data
            section_name = '.data'
          when :functions
            section_name = '.text'
          else
            section_name = section.to_s
          end
          io.puts "section #{section_name}"
          io.puts code
          io.puts
        end
      end
    end

  end
end