ruby-libjit 0.1.0

data/ext/minimal_node.h

@@ -0,0 +1,52 @@
+#ifndef minimal_node_h
+#define minimal_node_h
+
+#ifdef NEED_MINIMAL_NODE
+
+#include "ruby.h"
+
+typedef struct RNode {
+  unsigned long flags;
+  void * reserved;
+  union {
+    struct RNode * node;
+    VALUE (*cfunc)(ANYARGS);
+  } u1;
+  union {
+    struct RNode * node;
+    VALUE value;
+  } u2;
+  union {
+    struct RNode * node;
+  } u3;
+} NODE;
+
+#define nd_cfnc u1.cfunc
+#define nd_rval u2.value
+
+#define NEW_NODE(t,a0,a1,a2) rb_node_newnode((t),(VALUE)(a0),(VALUE)(a1),(VALUE)(a2))
+
+/* TODO: No way to know the correct size of node_type */
+enum node_type {
+  NODE_FOO,
+};
+
+void rb_add_method(VALUE, ID, NODE *, int);
+NODE *rb_node_newnode(enum node_type, VALUE, VALUE, VALUE);
+
+extern int NODE_MEMO;
+extern int NODE_METHOD;
+extern int NODE_FBODY;
+extern int NODE_CFUNC;
+
+void Init_minimal_node();
+
+#define NOEX_PUBLIC 0x0
+
+#define NEW_METHOD(n,x,v) NEW_NODE(NODE_METHOD,x,n,v)
+#define NEW_FBODY(n,i) NEW_NODE(NODE_FBODY,i,n,0)
+#define NEW_CFUNC(f,c) NEW_NODE(NODE_CFUNC,f,c,0)
+
+#endif
+
+#endif

data/ext/rubyjit.h

@@ -0,0 +1,20 @@
+#ifndef RUBYJIT_H
+#define RUBYJIT_H
+
+enum Ruby_Libjit_Tag
+{
+  RJT_OBJECT,
+  RJT_ID,
+  RJT_FUNCTION_PTR,
+  RJT_RUBY_VARARG_SIGNATURE,
+  RJT_VALUE_OBJECTS,
+  RJT_FUNCTIONS,
+  RJT_CONTEXT,
+  RJT_TAG_FOR_SIGNATURE
+};
+
+extern jit_type_t jit_type_VALUE;
+extern jit_type_t jit_type_ID;
+extern jit_type_t jit_type_Function_Ptr;
+
+#endif

data/ext/rubypp.rb

@@ -0,0 +1,97 @@
+class Preprocessor
+  def initialize(input, output, filename)
+    @input = input
+    @output = output
+    @filename = filename
+    @linenum = 1
+  end
+
+  def getline
+    line = @input.gets
+    @linenum += 1 if not line.nil?
+    return line
+  end
+
+  def preprocess
+    success = false
+    begin
+      loop do
+        line = getline
+        break if line.nil?
+        case line
+        when /(.*[^\\]|^)\#\{(.*?)\}(.*)/
+          puts "#{$1}#{evaluate($2, @linenum)}#{$3}"
+        when /^\#ruby\s+<<(.*)/
+          marker = $1
+          str = ''
+          evalstart = @linenum
+          loop do
+            line = getline
+            if line.nil? then
+              raise "End of input without #{marker}"
+            end
+            break if line.chomp == marker
+            str << line
+          end
+          result = evaluate(str, evalstart)
+          puts result if not result.nil?
+        when /^\#ruby\s+(.*)/
+          str = line = $1
+          while line[-1] == ?\\
+            str.chop!
+            line = getline
+            break if line.nil?
+            line.chomp!
+            str << line
+          end
+          result = evaluate(str, @linenum)
+          puts result if not result.nil?
+        else
+          puts line
+        end
+      end
+      success = true
+    ensure
+      if not success then
+        $stderr.puts "Error on line #{@linenum}:"
+      end
+    end
+  end
+
+  def evaluate(str, linenum)
+    result = eval(str, TOPLEVEL_BINDING, @filename, linenum)
+    success = true
+    return result
+  end
+
+  def puts(line='')
+    @output.puts(line)
+  end
+end
+
+def puts(line='')
+  $preprocessor.puts(line)
+end
+
+def rubypp(input_file, output_file)
+  input = input_file ? File.open(input_file) : $stdin
+  output = output_file ? File.open(output_file, 'w') : $stdout
+
+  success = false
+  begin
+    $preprocessor = Preprocessor.new(input, output, input_file || "(stdin)")
+    $preprocessor.preprocess()
+    success = true
+  ensure
+    if not success then
+      File.unlink(output_file) rescue Errno::ENOENT
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  input_file = ARGV[0]
+  output_file = ARGV[1]
+  rubypp(input_file, output_file)
+end
+

data/lib/jit/array.rb

@@ -0,0 +1,135 @@
+require 'jit'
+require 'jit/value'
+
+module JIT
+
+  # An abstraction for a fixed-length array type.
+  #
+  # Example usage:
+  #
+  #   array_type = JIT::Array.new(JIT::Type::INT, 4)
+  #
+  #   JIT::Context.build do |context|
+  #     signature = JIT::Type.create_signature(
+  #         JIT::ABI::CDECL, JIT::Type::INT, [ ])
+  #
+  #     function = JIT::Function.compile(context, signature) do |f|
+  #       array_instance = array_type.create(f)
+  #       array_instance[0] = f.const(JIT::Type::INT, 42)
+  #       f.insn_return(array_instance[0])
+  #     end
+  #
+  #   end
+  #
+  class Array < JIT::Type
+    attr_reader :type
+    attr_reader :length
+
+    # Create a new JIT array type.
+    #
+    # +type+::   The type of the elements in the array.
+    # +length+:: The number of elements in the array.
+    #
+    def self.new(type, length)
+      array = self.create_struct([ type ] * length)
+      array.instance_eval do
+        @type = type
+        @length = length
+      end
+      return array
+    end
+
+    # Wrap an existing array.
+    #
+    # +ptr+:: A pointer to the first element in the array.
+    #
+    def wrap(ptr)
+      return Instance.wrap(self, ptr)
+    end
+
+    # Create a new array.
+    #
+    # +function+:: The JIT::Function this array will be used in.
+    #
+    def create(function)
+      instance = function.value(self)
+      ptr = function.insn_address_of(instance)
+      return wrap(ptr)
+    end
+
+    # Return the offset (in bytes) of the element at the given +index+.
+    #
+    # +index+:: The index of the desired element.
+    #
+    def offset_of(index)
+      return self.get_offset(index)
+    end
+
+    # Return the type of the element at the given +index+.
+    #
+    # +index+:: The index of the desired element.
+    #
+    def type_of(index)
+      return @type
+    end
+
+    # An abstraction for an instance of a fixed-length array.
+    #
+    class Instance < JIT::Value
+      attr_reader :array_type
+      attr_reader :type
+      attr_reader :ptr
+
+      # TODO: This breaks code below?
+      # attr_reader :function
+
+      # Wrap an existing array.
+      #
+      # +array_type+:: The JIT::Array type to wrap.
+      # +ptr+::        A pointer to the first element in the array.
+      #
+      def self.wrap(array_type, ptr)
+        pointer_type = JIT::Type.create_pointer(array_type)
+        value = self.new_value(ptr.function, pointer_type)
+        value.store(ptr)
+        value.instance_eval do
+          @array_type = array_type
+          @type = array_type.type
+          @function = ptr.function
+          @ptr = ptr
+        end
+        return value
+      end
+
+      # Generate JIT code to retrieve the element at the given +index+.
+      #
+      # +index+:: The index of the desired element.  The value of the
+      #           index must be known at compile-time.
+      #
+      def [](index)
+        @function.insn_load_relative(
+            @ptr,
+            @array_type.offset_of(index),
+            @array_type.type_of(index))
+      end
+
+      # Generate JIT code to assign to the element at the given +index+.
+      #
+      # +index+:: The index of the desired element.  The value of the
+      #           index must be known at compile-time.
+      # +value+:: The JIT::Value to assign to the element.
+      #
+      def []=(index, value)
+        @function.insn_store_relative(
+            @ptr,
+            @array_type.offset_of(index),
+            value)
+      end
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  a = JIT::Array.new()
+end
+

data/lib/jit/function.rb

@@ -0,0 +1,201 @@
+require 'jit'
+
+module JIT
+  class Function
+    # An abstraction for conditionals.
+    #
+    # Example usage:
+    #
+    #   function.if(condition) {
+    #     # condition is true
+    #   } .elsif(condition2) {
+    #     # condition2 is true
+    #   } .else {
+    #     # condition1 and condition2 are false
+    #   } .end
+    #
+    # Caution: if you omit end, then the generated code will have
+    # undefined behavior, but there will be no warning generated.
+    def if(cond, end_label = Label.new, &block)
+      false_label = Label.new
+      insn_branch_if_not(cond, false_label)
+      block.call
+      insn_branch(end_label)
+      insn_label(false_label)
+      return If.new(self, end_label)
+    end
+
+    # An abstraction for an inverted conditional.
+    #
+    # Example usage:
+    #
+    #   function.unless(condition) {
+    #     # condition is false
+    #   } .elsunless(condition2) {
+    #     # condition2 is false
+    #   } .else {
+    #     # condition1 and condition2 are true
+    #   } .end
+    #
+    # Caution: if you omit end, then the generated code will have
+    # undefined behavior, but there will be no warning generated.
+    def unless(cond, end_label = Label.new, &block)
+      true_label = Label.new
+      insn_branch_if(cond, true_label)
+      block.call
+      insn_branch(end_label)
+      insn_label(true_label)
+      return If.new(self, end_label)
+    end
+
+    # :nodoc:
+    class If
+      def initialize(function, end_label)
+        @function = function
+        @end_label = end_label
+      end
+
+      def else(&block)
+        block.call
+        return self
+      end
+
+      def elsif(cond, &block)
+        return @function.if(cond, @end_label, &block)
+      end
+
+      def elsunless(cond, &block)
+        return @function.unless(cond, @end_label, &block)
+      end
+
+      def end
+        @function.insn_label(@end_label)
+      end
+    end
+
+    # An abstraction for a multi-way conditional.
+    #
+    # Example usage:
+    #
+    #   function.case(value1)
+    #   .when(value2) {
+    #     # value1 == value2
+    #   }.when(value3) {
+    #     # value1 == value3
+    #   } .else {
+    #     # all other cases fell through
+    #   } .end
+    #
+    # Caution: if you omit end, then the generated code will have
+    # undefined behavior, but there will be no warning generated.
+    def case(value)
+      return Case.new(self, value)
+    end
+
+    # :nodoc:
+    class Case
+      def initialize(function, value)
+        @function = function
+        @value = value
+        @if = nil
+      end
+
+      def when(value, &block)
+        if not @if then
+          @if = @function.if(value == @value, &block)
+        else
+          @if.elsif(value == @value, &block)
+        end
+        return self
+      end
+
+      def else(&block)
+        @if.else(&block)
+      end
+
+      def end
+        @if.end if @if
+      end
+    end
+
+    # Usage:
+    #
+    #   until(proc { <condition> }) {
+    #     # loop body
+    #   } .end
+    #
+    def until(cond, &block)
+      start_label = Label.new
+      done_label = Label.new
+      insn_label(start_label)
+      insn_branch_if(cond.call, done_label)
+      loop = Loop.new(self, start_label, done_label)
+      block.call(loop)
+      insn_branch(start_label)
+      insn_label(done_label)
+      return loop
+    end
+
+    # Usage:
+    #
+    #   while(proc { <condition> }) {
+    #     # loop body
+    #   } .end
+    #
+    def while(cond, &block)
+      start_label = Label.new
+      done_label = Label.new
+      insn_label(start_label)
+      insn_branch_if_not(cond.call, done_label)
+      loop = Loop.new(self, start_label, done_label)
+      block.call(loop)
+      insn_branch(start_label)
+      insn_label(done_label)
+      return loop
+    end
+
+    # :nodoc:
+    class Loop
+      def initialize(function, start_label, done_label)
+        @function = function
+        @redo_label = start_label
+        @done_label = done_label
+      end
+
+      def end
+      end
+
+      def break
+        @function.insn_branch(@done_label)
+      end
+
+      def redo
+        @function.insn_branch(@redo_label)
+      end
+
+      def redo_from_here
+        @redo_label = JIT::Label.new
+        @function.insn_label(@redo_label)
+      end
+    end
+
+    # An alias for get_param
+    def param(n)
+      self.get_param(n)
+    end
+
+    # An alias for insn_return
+    def return(result)
+      self.insn_return(result)
+    end
+
+    # Create a JIT::Context and compile a new function within that
+    # context.
+    def self.build(*args, &block)
+      JIT::Context.build do |context|
+        JIT::Function.compile(context, *args, &block)
+      end
+    end
+  end
+end
+

data/lib/jit/struct.rb

@@ -0,0 +1,163 @@
+require 'jit'
+
+module JIT
+
+  # An abstraction for a record composed of heterogenous fields.
+  #
+  # Example usage:
+  #
+  #   point_type = JIT::Struct.new(
+  #       [ :x, JIT::Type::INT ],
+  #       [ :y, JIT::Type::INT ],
+  #       [ :z, JIT::Type::INT ])
+  #
+  #   JIT::Context.build do |context|
+  #     signature = JIT::Type.create_signature(
+  #         JIT::ABI::CDECL, JIT::Type::INT, [ ])
+  #
+  #     function = JIT::Function.compile(context, signature) do |f|
+  #       point = point_type.create(f)
+  #       point.x = function.const(JIT::Type::INT, 1)
+  #       point.y = function.const(JIT::Type::INT, 2)
+  #       point.z = function.const(JIT::Type::INT, 3)
+  #       f.insn_return(point.x)
+  #     end
+  #
+  #   end
+  #
+  class Struct < JIT::Type
+
+    # Construct a new JIT structure type.
+    #
+    # +members+:: A list of members, where each element in the list is a
+    #             two-element array [ :name, type ]
+    #
+    def self.new(*members)
+      member_names = members.map { |m| m[0].to_s.intern }
+      member_types = members.map { |m| m[1] }
+      type = self.create_struct(member_types)
+      type.instance_eval do
+        @members = members
+        @member_names = member_names
+        @member_types = member_types
+        @index = Hash[*@member_names.zip((0..@member_names.size).to_a).flatten]
+      end
+      return type
+    end
+
+    # Return the names of the members in the structure.
+    def members
+      return @member_names
+    end
+
+    # Wrap an existing structure.
+    #
+    # +ptr+:: A pointer to the first element in the structure.
+    #
+    def wrap(ptr)
+      return Instance.new(self, ptr)
+    end
+
+    # Create a new structure.
+    #
+    # +function+:: The JIT::Function this structure will be used in.
+    #
+    def create(function)
+      instance = function.value(self)
+      ptr = function.insn_address_of(instance)
+      return wrap(ptr)
+    end
+
+    # Return the offset (in bytes) of the element with the given name.
+    #
+    # +name+:: The name of the desired element.
+    #
+    def offset_of(name)
+      name = (Symbol === name) ? name : name.to_s.intern
+      return self.get_offset(@index[name])
+    end
+
+    # Change the offset of the element with the given name.
+    #
+    # +name+::   The name of the desired element.
+    # +offset+:: The new offset.
+    #
+    def set_offset_of(name, offset)
+      name = (Symbol === name) ? name : name.to_s.intern
+      return self.set_offset(@index[name], offset)
+    end
+
+    # Return the type of the element with the given name.
+    #
+    # +name+:: The name of the desired element.
+    #
+    def type_of(name)
+      name = (Symbol === name) ? name : name.to_s.intern
+      return @member_types[@index[name]]
+    end
+
+    # An abstraction for an instance of a JIT::Struct.
+    #
+    class Instance
+      attr_reader :ptr
+
+      # Wrap an existing structure.
+      #
+      # +struct+:: The JIT::Struct type to wrap.
+      # +ptr+      A pointer to the first element of the structure.
+      #
+      def initialize(struct, ptr)
+        @struct = struct
+        @function = ptr.function
+        @ptr = ptr
+
+        mod = Module.new do
+          struct.members.each do |name|
+            define_method("#{name}") do
+              self[name] # return
+            end
+
+            define_method("#{name}=") do |value|
+              self[name] = value # return
+            end
+          end
+        end
+
+        extend(mod)
+      end
+
+      # Generate JIT code to retrieve the element with the given name.
+      #
+      # +name+:: The name of the desired element.
+      #
+      def [](name)
+        @function.insn_load_relative(
+            @ptr,
+            @struct.offset_of(name),
+            @struct.type_of(name))
+      end
+
+      # Generate JIT code to assign to the element with the given name.
+      #
+      # +name+::  The name of the desired element.
+      # +value+:: The JIT::Value to assign to the element.
+      #
+      def []=(name, value)
+        @function.insn_store_relative(
+            @ptr,
+            @struct.offset_of(name),
+            value)
+      end
+
+      def members
+        return @struct.members
+      end
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  s = JIT::Struct.new()
+  p s
+end
+