voodoo 1.0.2 → 1.1.1

data/bin/voodooc

@@ -3,9 +3,10 @@
 require 'getoptlong'
 
 require 'voodoo'
+require 'voodoo/generators/dummy_generator'
 
-usage="USAGE: voodooc [options] <input file>"
-help=<<EOT
+USAGE="USAGE: voodooc [options] <input file>"
+HELP=<<EOT
 Input file denotes the file to compile. The special name '-' causes
 voodooc to read from standard input. In that case, the -o option is
 mandatory.
@@ -18,6 +19,10 @@ Valid options are:
         Select target architecture. Use -a help to get a list of
         supported architectures.
 
+-c
+--check
+        Check program for correctness, but do not actually compile it.
+
 -f <format>
 --format <format>
 --output-format <format>
@@ -25,7 +30,7 @@ Valid options are:
         supported output formats for architecture.
 
 --features
-        Lists the features supported by this implementation. The features
+        List the features supported by this implementation. The features
         are listed in the format <feature name><tab><version>, ordered
         by feature name. The program exits after printing the list of
         features; no compilation is performed.
@@ -44,21 +49,67 @@ Valid options are:
         Display version information and exit. No compilation will be performed.
 EOT
 
+architecture = Voodoo::Config.default_architecture
+check_only = false
 input_file = nil
 output_file = nil
-architecture = Voodoo::Config.default_architecture
 output_format = Voodoo::Config.default_format
 show_features = false
 
+# Gets the input file name from the command line.
+def get_input_file_name
+  if ARGV.length == 1
+    input_file = ARGV[0]
+  else
+    if ARGV.length < 1
+      $stderr.puts "no input files"
+    else
+      $stderr.puts "Too many arguments"
+    end
+    $stderr.puts USAGE
+    exit 0x80
+  end
+  input_file
+end
+
+# If error is a Voodoo::Compiler::Error, prints error messages.
+# Else, re-raises error.
+def handle_error error
+  # If error is a compiler error, iterate over all child errors and
+  # print user-friendly messages. Else, re-raise so that the default
+  # handling is performed.
+  if error.kind_of? Voodoo::Compiler::Error
+    error.errors.each do |e|
+      message = ''
+      if e.start_line != nil
+        message << "#{e.start_line}: "
+        if e.input_name != nil
+          message = "#{e.input_name}:#{message}"
+        else
+          message = "line #{message}"
+        end
+      end
+      message << e.message
+      $stderr.puts message
+      if e.text != nil
+        $stderr.print "\n  #{e.text.gsub("\n", "\n  ")}\n"
+      end
+    end
+  else
+    raise error
+  end
+end
+
 #
 # Process command line
 #
 
 opts = GetoptLong.new(
-  ['--help', '-h', GetoptLong::NO_ARGUMENT ],
-  ['--arch', '--architecture', '-a', GetoptLong::REQUIRED_ARGUMENT ],
+  ['--arch', '--architecture', '-a', GetoptLong::REQUIRED_ARGUMENT],
+  ['--check', '-c', GetoptLong::NO_ARGUMENT],
   ['--features', GetoptLong::NO_ARGUMENT],
-  ['--output-file', '--output', '-o', GetoptLong::REQUIRED_ARGUMENT ],
+  ['--help', '-h', GetoptLong::NO_ARGUMENT],
+  ['--output-file', '--output', '-o', GetoptLong::REQUIRED_ARGUMENT],
   ['--output-format', '--format', '-f', GetoptLong::REQUIRED_ARGUMENT ],
   ['--version', GetoptLong::NO_ARGUMENT]
 )
@@ -66,14 +117,16 @@ opts = GetoptLong.new(
 # Process options
 opts.each do |opt, arg|
   case opt
-  when '--help'
-    puts usage
-    puts help
-    exit
   when '--arch'
     architecture = arg.to_sym
+  when '--check'
+    check_only = true
   when '--features'
     show_features = true
+  when '--help'
+    puts USAGE
+    puts HELP
+    exit
   when '--output-file'
     output_file = arg
   when '--output-format'
@@ -99,6 +152,24 @@ if output_format == :help
   exit
 end
 
+if check_only
+  input_file = get_input_file_name
+  infile = input_file == '-' ? $stdin : open(input_file)
+  begin
+    parser = Voodoo::Parser.new infile
+    generator = Voodoo::DummyGenerator.new
+    compiler = Voodoo::Compiler.new parser, generator, nil
+    compiler.compile
+  rescue => error
+    handle_error error
+    exit 1
+  ensure
+    infile.close
+  end
+  puts 'OK'
+  exit 0
+end
+
 # Select code generator based on output format
 begin
   generator = Voodoo::CodeGenerator.get_generator :architecture => architecture,
@@ -124,20 +195,7 @@ if show_features
   exit
 end
 
-# Get input file name
-if ARGV.length == 1
-  input_file = ARGV[0]
-else
-  if ARGV.length < 1
-    $stderr.puts "no input files"
-  else
-    $stderr.puts "Too many arguments"
-  end
-  $stderr.puts usage
-  exit 0x80
-end
-
-
+input_file = get_input_file_name
 
 #
 # Compile
@@ -171,30 +229,8 @@ rescue => e
     File::unlink(output_file) if File::exists?(output_file)
   end
 
-  # If e is a compiler error, iterate over all child errors and
-  # print user-friendly messages. Else, re-raise so that the default
-  # handling is performed.
-  if e.kind_of? Voodoo::Compiler::Error
-    e.errors.each do |error|
-      message = ''
-      if error.start_line != nil
-        message << "#{error.start_line}: "
-        if error.input_name != nil
-          message = "#{error.input_name}:#{message}"
-        else
-          message = "line #{message}"
-        end
-      end
-      message << error.message
-      $stderr.puts message
-      if error.text != nil
-        $stderr.print "\n  #{error.text.gsub("\n", "\n  ")}\n"
-      end
-    end
-    exit 1
-  else
-    raise
-  end
+  handle_error e
+  exit 1
 ensure
   outfile.close
   infile.close

data/lib/voodoo.rb

@@ -10,22 +10,27 @@ require 'voodoo/parser'
 # programming language designed to be a thin abstraction of the CPU's
 # native instruction set.
 #
-# The compiler consists of three parts:
+# The compiler consists of four parts:
 #
 # 1. The parser (Voodoo::Parser), which reads 
 #    Voodoo[http://inglorion.net/documents/designs/voodoo/] source code and
 #    turns it into Ruby[http://www.ruby-lang.org/] objects.
 #
-# 2. The code generator (a class that implements the methods of
+# 2. The validator (Voodoo::Validator), which takes Voodoo code in Ruby
+#    object form and checks that it is valid. The parser calls the validator,
+#    so if you are using the parser to get Voodoo code, it will already have
+#    been validated.
+#
+# 3. The code generator (a class that implements the methods of
 #    Voodoo::CommonCodeGenerator), which provides methods that generate
 #    code for the target platform.
 #
-# 3. The compiler driver (Voodoo::Compiler), which reads from the parser
+# 4. The compiler driver (Voodoo::Compiler), which reads from the parser
 #    and calls the appropriate methods of the code generator.
 #
-# Both the parser and the code generators can be used on their own. For
-# example, you could use the code generator to generate native code for
-# your own programming language without first creating a
+# The parser, validator, and code generators can be used on their own.
+# For example, you could use the code generator to generate native
+# code for your own programming language without first creating a
 # Voodoo[http://inglorion.net/documents/designs/voodoo/] program.
 #
 # Instead of instantiating a code generator directly, it is recommended

data/lib/voodoo/code_generator.rb

@@ -11,7 +11,7 @@ module Voodoo
 
     module_function
 
-    # Register a code generator.
+    # Registers a code generator.
     # Example:
     #   Voodoo::CodeGenerator.register_generator I386NasmGenerator,
     #                                            :architecture => :i386,
@@ -28,7 +28,7 @@ module Voodoo
       end
     end
 
-    # Get a code generator for the specified parameters
+    # Gets a code generator for the specified parameters.
     def get_generator params = {}
       params[:architecture] = Config.default_architecture \
         unless params[:architecture]
@@ -44,23 +44,23 @@ module Voodoo
       end
     end
 
-    # Tests if a given architecture is supported
+    # Tests if a given architecture is supported.
     def architecture_supported? arch
       @@generators.has_key? arch.to_sym
     end
 
-    # Get an array of supported architectures
+    # Gets an array of supported architectures.
     def architectures
       @@generators.keys
     end
 
-    # Tests if a given format is supported for a given architecture
+    # Tests if a given format is supported for a given architecture.
     def format_supported? arch, format
       architecture_supported?(arch.to_sym) &&
         @@generators[arch.to_sym].has_key?(format.to_sym)
     end
 
-    # Get an array of supported formats for a given architecture
+    # Gets an array of supported formats for a given architecture.
     def formats architecture
       @@generators[architecture.to_sym].keys
     end

data/lib/voodoo/compiler.rb

@@ -23,7 +23,7 @@ module Voodoo
       end
     end
 
-    # Initialize a compiler.
+    # Initializes a compiler.
     #
     # Parameters:
     # [parser] the parser to be used (see Voodoo::Parser)
@@ -36,7 +36,7 @@ module Voodoo
       @output = output
     end
 
-    # Perform the compilation.
+    # Performs the compilation.
     def compile
       section = :code
       errors = []

data/lib/voodoo/config.rb

@@ -2,15 +2,15 @@ module Voodoo
   # Methods to get and set configuration parameters
   module Config
     IMPLEMENTATION_NAME = 'Voodoo Compiler'
-    IMPLEMENTATION_VERSION = '1.0.2'
+    IMPLEMENTATION_VERSION = '1.1.1'
 
     # Class that holds configuration parameters
     class Configuration
       def initialize
         @default_architecture = :auto
         @default_format = :elf
-        @gas_command = "as"
-        @nasm_command = "nasm"
+        @gas_command = "/usr/bin/as"
+        @nasm_command = ""
       end
 
       attr_accessor :default_format,

data/lib/voodoo/generators/amd64_nasm_generator.rb

@@ -1,4 +1,5 @@
 require 'voodoo/generators/nasm_generator'
+require 'set'
 
 module Voodoo
   # = AMD64 NASM Code Generator
@@ -45,15 +46,25 @@ module Voodoo
   #   arg_1
   #   :
   #   arg_5
-  #   local_0
-  #   local_1
+  #   saved_r12
+  #   :
+  #   saved_r15
+  #   local_4
   #   :
   #   local_n   <-- rsp
   #
+  #
+  # == Callee-Save Registers
+  #
+  # +rbp+, +rbx+, and +r12+ through +r15+ are callee-save registers.
+  #
+  # All other registers are caller-save.
+  #
   class AMD64NasmGenerator < NasmGenerator
     def initialize params = {}
       # Number of bytes in a word
-      @WORDSIZE = 8
+      @WORDSIZE_BITS = 3
+      @WORDSIZE = 1 << @WORDSIZE_BITS
       # Word name in NASM lingo
       @WORD_NAME = 'qword'
       # Default alignment for code
@@ -63,28 +74,40 @@ module Voodoo
       # Default alignment for functions
       @FUNCTION_ALIGNMENT = 16
       # Register used for return values
-      @RETURN_REG = 'rax'
-      # Register used as scratch register
-      @SCRATCH_REG = 'r11'
+      @RETURN_REG = :rax
+      # Stack alignment restrictions
+      @STACK_ALIGNMENT_BITS = @WORDSIZE_BITS
+      @STACK_ALIGNMENT = 1 << @STACK_ALIGNMENT_BITS
+      @TEMPORARIES = [:r11]
       # Registers used for argument passing
-      @ARG_REGS = ['rdi', 'rsi', 'rdx', 'rcx', 'r8', 'r9']
+      @ARG_REGS = [:rdi, :rsi, :rdx, :rcx, :r8, :r9]
+      @NREG_ARGS = @ARG_REGS.length
+      # Registers used to store locals
+      @LOCAL_REGISTERS = [:r12, :r13, :r14, :r15]
+      @NLOCAL_REGISTERS = @LOCAL_REGISTERS.length
+      @LOCAL_REGISTERS_SET = Set.new @LOCAL_REGISTERS
       # Accumulator index
-      @AX = 'rax'
+      @AX = :rax
       # Base index
-      @BX = 'rbx'
+      @BX = :rbx
       # Count index
-      @CX = 'rcx'
+      @CX = :rcx
       # Data index
-      @DX = 'rdx'
+      @DX = :rdx
       # Base pointer
-      @BP = 'rbp'
+      @BP = :rbp
       # Stack pointer
-      @SP = 'rsp'
+      @SP = :rsp
+      @SAVE_FRAME_REGISTERS = [:rbx, :r12, :r13, :r14, :r15, :rsp, :rbp]
+      @SAVED_FRAME_LAYOUT = {}
+      @SAVE_FRAME_REGISTERS.each_with_index { |r,i| @SAVED_FRAME_LAYOUT[r] = i }
       super params
       @features.merge! \
         :'bits-per-word' => '64',
         :'byte-order' => 'little-endian',
         :'bytes-per-word' => '8'
+      @saved_registers = []
+      @function_end_label = nil
     end
 
     #
@@ -100,15 +123,33 @@ module Voodoo
     # == Functions
     #
 
-    # Call a function.
+    # Emits function preamble and declare +formals+ as function arguments.
+    def begin_function formals, nlocals
+      environment = Environment.new @environment
+      @saved_registers = []
+      @environment = environment
+      emit "push #{@BP}\nmov #{@BP}, #{@SP}\n"
+      formals.each_with_index do |arg,i|
+        @environment.add_arg arg, arg_offset(i)
+        comment "# #{arg} is at #{offset_reference(@environment[arg])}"
+        emit "push #{@ARG_REGS[i]}\n" if i < @NREG_ARGS
+      end
+      emit "sub #{@SP}, #{nlocals * @WORDSIZE}\n"
+      number_of_register_locals(nlocals).times do |i|
+        register = @LOCAL_REGISTERS[i]
+        ref = offset_reference saved_local_offset(i)
+        emit "mov #{ref}, #{register}\n"
+        @saved_registers << register
+      end
+      @function_end_label = gensym
+    end
+
+    # Calls 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 - 1)] || []
+      register_args = args[0..(@NREG_ARGS - 1)] || []
       # 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"
+      stack_args = args[@NREG_ARGS..-1] || []
       # Push stack arguments
       stack_args.reverse.each { |arg| push_qword arg }
       # Load register arguments
@@ -120,13 +161,15 @@ module Voodoo
         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"
+      with_temporary do |temporary|
+        value_ref = load_value func, temporary
+        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
       end
       # Clean up stack
       unless stack_args.empty?
@@ -134,20 +177,33 @@ module Voodoo
       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
+    # Ends a function body.
+    def end_function
+      label @function_end_label
+      # Restore saved registers
+      @saved_registers.each_with_index do |register,i|
+        ref = offset_reference saved_local_offset(i)
+        emit "mov #{register}, #{ref}\n"
+      end
+      # Destroy frame.
+      emit "leave\n"
+      # Return.
+      emit "ret\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.
+    # Returns from a function.
+    def ret *words
+      eval_expr words, @AX unless words.empty?
+      goto @function_end_label
+    end
+
+    # Calls 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,
@@ -155,62 +211,69 @@ module Voodoo
       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
+      else
 
-      # 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 any arguments are going to be overwritten before they are
+        # used, save them to new local variables and use those instead.
+        (args.length - 1).downto(@NREG_ARGS) do |i|
+          arg = args[i]
+          next unless symbol?(arg)
+          old_arg_offset = @environment[arg]
+          next if old_arg_offset == nil || old_arg_offset < 0
+          # arg is an argument that was passed on the stack.
+          new_arg_offset = arg_offset i
+          next unless old_arg_offset > new_arg_offset
+          # arg will be overwritten before it is used.
+          # Save it in a newly created temporary variable,
+          # then use that instead.
+          newsym = @environment.gensym
+          let newsym, arg
+          args[i] = newsym
+        end
 
-        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
+        # Same for the function we will be calling.
+        if symbol?(func)
+          offset = @environment[func]
+          if offset != nil && offset > 0
             newsym = @environment.gensym
-            let newsym, arg
-            # Change reference
-            if i >= 0
-              args[i] = newsym
-            else
-              func = newsym
-            end
+            let newsym, func
+            func = newsym
           end
         end
-        i = i - 1
-      end
 
-      # Set stack arguments
-      if args.length > number_of_register_arguments
-        (args.length - 1).downto(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 #{@SCRATCH_REG}, #{value_ref}\n"
-            emit "mov #{newarg_ref}, #{@SCRATCH_REG}\n"
+        # Set stack arguments
+        if args.length > @NREG_ARGS
+          (args.length - 1).downto(@NREG_ARGS).each do |i|
+            arg = args[i]
+
+            with_temporary do |temporary|
+              value_ref = load_value arg, temporary
+              newarg_ref = load_arg i
+              # Elide code if source is same as destination
+              unless value_ref == newarg_ref
+                emit "mov #{temporary}, #{value_ref}\n"
+                emit "mov #{newarg_ref}, #{temporary}\n"
+              end
+            end
           end
         end
-      end
 
-      # Set register arguments
-      number_of_register_arguments(args.length).times do |i|
-        register = @ARG_REGS[i]
-        load_value_into_register args[i], register
-      end
+        # Set register arguments
+        number_of_register_arguments(args.length).times do |i|
+          register = @ARG_REGS[i]
+          load_value_into_register args[i], register
+        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"
+        # 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
     end
 
@@ -218,8 +281,8 @@ module Voodoo
     # == Loading Values
     #
 
-    # Load the value of the nth argument
-    def load_arg n, reg = @SCRATCH_REG
+    # Loads the value of the nth argument.
+    def load_arg n
       if register_argument?(n)
         # Arguments that were originally passed in a register
         # are now below rbp
@@ -227,58 +290,68 @@ module Voodoo
       else
         # Arguments that were originally passed on the stack
         # are now above rbp, starting 2 words above it
-        "[rbp + #{(n + 2 - number_of_register_arguments) * @WORDSIZE}]"
+        "[rbp + #{(n + 2 - @NREG_ARGS) * @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}]"
+    # Loads a symbol from the global offset table.
+    def load_symbol_from_got symbol, reg
+      "[rel #{symbol} wrt ..gotpc]"
     end
 
     #
-    # == Variables
+    # == Miscellaneous
     #
 
-    # 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"
+    # Returns the offset from rbp at which the nth argument is stored.
+    def arg_offset n
+      if n < @NREG_ARGS
+        (n + 1) * -@WORDSIZE
+      else
+        (n - @NREG_ARGS) * @WORDSIZE + 2 * @WORDSIZE
+      end
     end
 
-    #
-    # == Miscellaneous
-    #
+    # If the nth local is stored in a register, returns that register.
+    # Otherwise, returns the offset from the frame pointer.
+    def local_offset_or_register n
+      if n < @NLOCAL_REGISTERS
+        @LOCAL_REGISTERS[n]
+      else
+        (n + number_of_register_arguments + 1) * -@WORDSIZE
+      end
+    end
 
-    # Load a value and push it on the stack.
+    # Loads 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"
+      with_temporary do |temporary|
+        value_ref = load_value value, temporary
+        emit "push qword #{value_ref}\n"
+      end
     end
 
-    # Calculate the number of register arguments,
+    # Calculates 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
+    def number_of_register_arguments n = @environment.args
+      n < @NREG_ARGS ? n : @NREG_ARGS
     end
 
-    # Calculate the number of stack arguments,
+    # Calculates the number of locals that are stored in registers.
+    def number_of_register_locals n = @environment.locals
+      n < @NLOCAL_REGISTERS ? n : @NLOCAL_REGISTERS
+    end
+
+    # Calculates the number of stack arguments,
     # given the total number of arguments.
-    def number_of_stack_arguments n
-      [0, n - number_of_register_arguments].max
+    def number_of_stack_arguments n = @environment.args
+      x = n - @NREG_ARGS
+      x < 0 ? 0 : x
+    end
+
+    # Calculates the number of locals that are stored on the stack.
+    def number_of_stack_locals n = @environment.locals
+      x = n - @NLOCAL_REGISTERS
+      x < 0 ? 0 : x
     end
 
     # Tests if the nth argument is a register argument.
@@ -286,6 +359,11 @@ module Voodoo
       n < number_of_register_arguments
     end
 
+    # Returns the offset of the nth saved local.
+    def saved_local_offset n
+      (number_of_register_arguments + n + 1) * -@WORDSIZE
+    end
+
   end
 
   # Register class