ruby-libjit 0.1.0 → 0.2.0

data/README

@@ -1,4 +1,4 @@
-Ruby-libjit 0.1.0
+Ruby-libjit 0.2.0
 Copyright (C) 2008 Paul Brannan
 
 Ruby-libjit is a wrapper for the libjit library.  It provides basic
@@ -8,6 +8,12 @@ provided so that jit code may be written in a ruby-like manner.
 
 Please see the file COPYING for license information.
 
+To install it:
+
+  gem install ruby-libjit
+
+but you'll probably need to install libjit itself first (see below).
+
 A simple example:
 
   :include: sample/simple.rb
@@ -21,28 +27,13 @@ To build ruby-libjit, you will need to install libjit.  If it is not
 available pre-compiled for your platform, you may build the latest
 release like this:
 
-  $ wget ftp://ftp.gnu.org/gnu/dotgnu/pnet/libjit-0.1.0.tar.gz
-  $ tar xvfz libjit-0.1.0.tar.gz
-  $ cd libjit-0.1.0
-  $ ./configure
-  $ make
-  $ sudo make install
-
-Or the latest development version like this:
-
-  $ cvs -z3 -d:pserver:anonymous@cvs.sv.gnu.org:/sources/dotgnu-pnet co libjit
-  $ cd libjit
-  $ ./auto_gen.sh
+  $ wget ftp://ftp.gnu.org/gnu/dotgnu/libjit/libjit-0.1.2.tar.gz
+  $ tar xvfz libjit-0.1.2.tar.gz
+  $ cd libjit-0.1.2
   $ ./configure
   $ make
   $ sudo make install
 
-To build ruby-libjit, run setup.rb:
-
-  $ ruby setup.rb config
-  $ ruby setup.rb setup
-  $ sudo ruby setup.rb install
-
 For a more complete JIT framework and compiler for Ruby code, please
 take a look at Ludicrous:
 

data/ext/extconf.rb

@@ -1,6 +1,14 @@
 require 'mkmf'
+require 'rbconfig'
 
-if not have_library('jit', 'jit_init', ["jit/jit.h"]) then
+if Config::CONFIG['host_os'] =~ /cygwin|win32|windows/ then
+  need_windows_h = [ 'windows.h' ]
+  $defs << ' -DNEED_WINDOWS_H'
+else
+  need_windows_h = [ ]
+end
+
+if not have_library('jit', 'jit_init', need_windows_h + ["jit/jit.h"]) then
   $stderr.puts "libjit not found"
   exit 1
 end

data/ext/insns.inc.rpp

@@ -184,7 +184,6 @@ insns = [
   [ 'push'                 , _, V       ] ,
   [ 'push_ptr'             , _, V, T    ] ,
   [ 'pop_stack'            , _, N       ] ,
-  [ 'stack_top'            , V          ] ,
 ]
 
 insns.each do |name, retval_type, *arg_types|

data/ext/jit.c

@@ -2,6 +2,10 @@
 #define _GNU_SOURCE
 #endif
 
+#ifdef NEED_WINDOWS_H
+#include <windows.h>
+#endif
+
 #include <ruby.h>
 
 #include <stdio.h>
@@ -16,6 +20,14 @@
 #include "minimal_node.h"
 #endif
 
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(a) RARRAY(a)->len
+#endif
+
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(a) RARRAY(a)->ptr
+#endif
+
 static VALUE rb_mJIT;
 static VALUE rb_cContext;
 static VALUE rb_cFunction;
@@ -89,6 +101,18 @@ typedef jit_ptr jit_Function_Ptr;
  * ---------------------------------------------------------------------------
  */
 
+static VALUE lookup_const(VALUE module, VALUE symbol)
+{
+  if(SYMBOL_P(symbol))
+  {
+    return rb_const_get(module, SYM2ID(symbol));
+  }
+  else
+  {
+    return symbol;
+  }
+}
+
 static void check_type(char const * param_name, VALUE expected_klass, VALUE val)
 {
   if(!rb_obj_is_kind_of(val, expected_klass))
@@ -381,6 +405,7 @@ static VALUE function_value_klass(VALUE self, VALUE type_v, VALUE klass)
 
   Data_Get_Struct(self, struct _jit_function, function);
 
+  type_v = lookup_const(rb_cType, type_v);
   check_type("type", rb_cType, type_v);
   Data_Get_Struct(type_v, struct _jit_type, type);
 
@@ -514,6 +539,7 @@ static VALUE function_const(VALUE self, VALUE type_v, VALUE constant)
 
   Data_Get_Struct(self, struct _jit_function, function);
 
+  type_v = lookup_const(rb_cType, type_v);
   check_type("type", rb_cType, type_v);
   Data_Get_Struct(type_v, struct _jit_type, type);
 
@@ -537,9 +563,9 @@ static void convert_call_args(jit_function_t function, jit_value_t * args, VALUE
 {
   int j;
 
-  for(j = 0; j < RARRAY(args_v)->len; ++j)
+  for(j = 0; j < RARRAY_LEN(args_v); ++j)
   {
-    VALUE value = RARRAY(args_v)->ptr[j];
+    VALUE value = RARRAY_PTR(args_v)[j];
     jit_value_t arg;
 
     jit_type_t type = jit_type_get_param(signature, j);
@@ -596,7 +622,7 @@ static VALUE function_insn_call(int argc, VALUE * argv, VALUE self)
   check_type("called function", rb_cFunction, called_function_v);
   Data_Get_Struct(called_function_v, struct _jit_function, called_function);
 
-  num_args = RARRAY(args_v)->len;
+  num_args = RARRAY_LEN(args_v);
   args = ALLOCA_N(jit_value_t, num_args);
 
   signature = jit_function_get_signature(function);
@@ -650,7 +676,7 @@ static VALUE function_insn_call_native(int argc, VALUE * argv, VALUE self)
 
   Data_Get_Struct(signature_v, struct _jit_type, signature);
 
-  num_args = RARRAY(args_v)->len;
+  num_args = RARRAY_LEN(args_v);
   args = ALLOCA_N(jit_value_t, num_args);
 
   if(num_args != jit_type_num_params(signature))
@@ -989,27 +1015,31 @@ static VALUE wrap_type(jit_type_t type)
 static VALUE type_s_create_signature(
     VALUE klass, VALUE abi_v, VALUE return_type_v, VALUE params_v)
 {
-  jit_abi_t abi = NUM2INT(abi_v);
+  jit_abi_t abi;
   jit_type_t return_type;
   jit_type_t * params;
   jit_type_t signature;
   int j;
   int len;
 
+  return_type_v = lookup_const(rb_cType, return_type_v);
   check_type("return type", rb_cType, return_type_v);
-
   Data_Get_Struct(return_type_v, struct _jit_type, return_type);
 
   Check_Type(params_v, T_ARRAY);
-  len = RARRAY(params_v)->len;
+  len = RARRAY_LEN(params_v);
   params = ALLOCA_N(jit_type_t, len);
   for(j = 0; j < len; ++j)
   {
-    VALUE param = RARRAY(params_v)->ptr[j];
+    VALUE param = RARRAY_PTR(params_v)[j];
+    param = lookup_const(rb_cType, param);
     check_type("param", rb_cType, param);
     Data_Get_Struct(param, struct _jit_type, params[j]);
   }
 
+  abi_v = lookup_const(rb_mABI, abi_v);
+  abi = NUM2INT(abi_v);
+
   signature = jit_type_create_signature(abi, return_type, params, len, 1);
   return wrap_type(signature);
 }
@@ -1029,16 +1059,16 @@ static VALUE type_s_create_struct(
   int j;
 
   Check_Type(fields_v, T_ARRAY);
-  len = RARRAY(fields_v)->len;
+  len = RARRAY_LEN(fields_v);
   fields = ALLOCA_N(jit_type_t, len);
   for(j = 0; j < len; ++j)
   {
-    VALUE field = RARRAY(fields_v)->ptr[j];
+    VALUE field = RARRAY_PTR(fields_v)[j];
     check_type("field", rb_cType, field);
     Data_Get_Struct(field, struct _jit_type, fields[j]);
   }
 
-  struct_type = jit_type_create_struct(fields, RARRAY(fields_v)->len, 1);
+  struct_type = jit_type_create_struct(fields, RARRAY_LEN(fields_v), 1);
   return wrap_type_with_klass(struct_type, klass);
 }
 
@@ -1293,6 +1323,7 @@ static VALUE value_type(VALUE self)
   jit_type_t type;
   Data_Get_Struct(self, struct _jit_value, value);
   type = jit_value_get_type(value);
+  type = jit_type_copy(type);
   return wrap_type(type);
 }
 

data/lib/jit/array.rb

@@ -78,6 +78,10 @@ module JIT
     class Instance < JIT::Value
       attr_reader :array_type
       attr_reader :type
+
+      # A pointer to the first element of the array.  Note that this
+      # differs from +address+, which returns the address of a pointer
+      # to the array.
       attr_reader :ptr
 
       # TODO: This breaks code below?
@@ -129,7 +133,3 @@ module JIT
   end
 end
 
-if __FILE__ == $0 then
-  a = JIT::Array.new()
-end
-

data/lib/jit/function.rb

@@ -48,8 +48,7 @@ module JIT
       return If.new(self, end_label)
     end
 
-    # :nodoc:
-    class If
+    class If # :nodoc:
       def initialize(function, end_label)
         @function = function
         @end_label = end_label
@@ -92,8 +91,7 @@ module JIT
       return Case.new(self, value)
     end
 
-    # :nodoc:
-    class Case
+    class Case # :nodoc:
       def initialize(function, value)
         @function = function
         @value = value
@@ -120,49 +118,50 @@ module JIT
 
     # Usage:
     #
-    #   until(proc { <condition> }) {
+    #   until { <condition> }.do {
     #     # loop body
     #   } .end
     #
-    def until(cond, &block)
+    def until(&block)
       start_label = Label.new
       done_label = Label.new
       insn_label(start_label)
-      insn_branch_if(cond.call, done_label)
+      insn_branch_if(block.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> }) {
+    #   while { <condition> }.do {
     #     # loop body
     #   } .end
     #
-    def while(cond, &block)
+    def while(&block)
       start_label = Label.new
       done_label = Label.new
       insn_label(start_label)
-      insn_branch_if_not(cond.call, done_label)
+      insn_branch_if_not(block.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
+    class Loop # :nodoc:
       def initialize(function, start_label, done_label)
         @function = function
+        @start_label = start_label
         @redo_label = start_label
         @done_label = done_label
       end
 
+      def do(&block)
+        block.call(self)
+        return self
+      end
+
       def end
+        @function.insn_branch(@start_label)
+        @function.insn_label(@done_label)
       end
 
       def break

data/lib/jit/pointer.rb

@@ -0,0 +1,98 @@
+require 'jit'
+require 'jit/value'
+
+module JIT
+
+  # An abstraction for a pointer to a non-void type.
+  #
+  # Example usage:
+  #
+  # TODO
+  #
+  class Pointer < JIT::Type
+    attr_reader :type
+
+    # Create a new JIT pointer type.
+    #
+    # +type+::   The pointed-to type.
+    #
+    def self.new(type)
+      pointer_type = self.create_pointer(type)
+      pointer_type.instance_eval do
+        @type = type
+      end
+      return pointer_type
+    end
+
+    # Wrap an existing void pointer.
+    #
+    # +ptr+:: The pointer to wrap.
+    #
+    def wrap(ptr)
+      return Instance.wrap(self, 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 index * @type.size
+    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 a pointer object.
+    #
+    class Instance < JIT::Value
+      # Wrap an existing void pointer.
+      #
+      # +array_type+:: The JIT::Array type to wrap.
+      # +ptr+::        A pointer to the first element in the array.
+      #
+      def self.wrap(pointer_type, ptr)
+        value = self.new_value(ptr.function, pointer_type)
+        value.store(ptr)
+        value.instance_eval do
+          @pointer_type = pointer_type
+          @pointed_type = pointer_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,
+            @pointer_type.offset_of(index),
+            @pointer_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,
+            @pointer_type.offset_of(index),
+            value)
+      end
+    end
+  end
+end
+

data/lib/jit/struct.rb

@@ -156,8 +156,3 @@ module JIT
   end
 end
 
-if __FILE__ == $0 then
-  s = JIT::Struct.new()
-  p s
-end
-

data/sample/fib.rb

@@ -2,19 +2,19 @@ require 'jit'
 
 fib = nil
 signature = JIT::Type.create_signature(
-    JIT::ABI::CDECL,
-    JIT::Type::INT,
-    [ JIT::Type::INT ])
+    :CDECL,
+    :INT,
+    [ :INT ])
 fib = JIT::Function.build(signature) do |f|
   n = f.param(0)
 
-  a = f.value(JIT::Type::INT, 0)
-  b = f.value(JIT::Type::INT, 1)
-  c = f.value(JIT::Type::INT, 1)
+  a = f.value(:INT, 0)
+  b = f.value(:INT, 1)
+  c = f.value(:INT, 1)
 
-  i = f.value(JIT::Type::INT, 0)
+  i = f.value(:INT, 0)
 
-  f.while(proc { i < n }) {
+  f.while{ i < n }.do {
     c.store(a + b)
     a.store(b)
     b.store(c)

data/test/test_jit_function.rb

@@ -169,7 +169,7 @@ class TestJitFunction < Test::Unit::TestCase
       function = JIT::Function.compile(context, signature) do |f|
         true_value = f.const(JIT::Type::INT, 1)
         false_value = f.const(JIT::Type::INT, 0)
-        f.while(proc { true_value }) {
+        f.while{ true_value }.do {
           f.insn_return true_value
         }.end
         f.insn_return false_value
@@ -189,7 +189,7 @@ class TestJitFunction < Test::Unit::TestCase
       function = JIT::Function.compile(context, signature) do |f|
         value = f.value(JIT::Type::INT)
         value.store(f.const(JIT::Type::INT, 0))
-        f.while(proc { value < f.const(JIT::Type::INT, 2) }) {
+        f.while{ value < f.const(JIT::Type::INT, 2) }.do {
           value.store(value + f.const(JIT::Type::INT, 1))
         }.end
         f.insn_return value
@@ -209,7 +209,7 @@ class TestJitFunction < Test::Unit::TestCase
       function = JIT::Function.compile(context, signature) do |f|
         true_value = f.const(JIT::Type::INT, 1)
         false_value = f.const(JIT::Type::INT, 0)
-        f.while(proc { false_value }) {
+        f.while{ false_value }.do {
           f.insn_return true_value
         }.end
         f.insn_return false_value
@@ -229,7 +229,7 @@ class TestJitFunction < Test::Unit::TestCase
       function = JIT::Function.compile(context, signature) do |f|
         true_value = f.const(JIT::Type::INT, 1)
         false_value = f.const(JIT::Type::INT, 0)
-        f.until(proc { false_value }) {
+        f.until{ false_value }.do {
           f.insn_return true_value
         }.end
         f.insn_return false_value
@@ -249,7 +249,7 @@ class TestJitFunction < Test::Unit::TestCase
       function = JIT::Function.compile(context, signature) do |f|
         value = f.value(JIT::Type::INT)
         value.store(f.const(JIT::Type::INT, 0))
-        f.until(proc { value == f.const(JIT::Type::INT, 2) }) {
+        f.until{ value == f.const(JIT::Type::INT, 2) }.do {
           value.store(value + f.const(JIT::Type::INT, 1))
         }.end
         f.insn_return value
@@ -269,7 +269,7 @@ class TestJitFunction < Test::Unit::TestCase
       function = JIT::Function.compile(context, signature) do |f|
         true_value = f.const(JIT::Type::INT, 1)
         false_value = f.const(JIT::Type::INT, 0)
-        f.until(proc { true_value }) {
+        f.until{ true_value }.do {
           f.insn_return true_value
         }.end
         f.insn_return false_value

data/test/test_jit_pointer.rb

@@ -0,0 +1,63 @@
+require 'jit/pointer'
+require 'jit/array'
+require 'jit/function'
+require 'test/unit'
+require 'assertions'
+
+class TestJitArray < Test::Unit::TestCase
+  include JitAssertions
+
+  def test_new_pointer
+    p_type = JIT::Pointer.new(JIT::Type::INT)
+    assert_equal JIT::Type::INT, p_type.type
+  end
+
+  # TODO: wrap
+
+  def test_offset_of
+    p_type = JIT::Pointer.new(JIT::Type::INT)
+    assert_equal 0, p_type.offset_of(0)
+    assert_equal 4, p_type.offset_of(1)
+    assert_equal 8, p_type.offset_of(2)
+    assert_equal 12, p_type.offset_of(3)
+    # TODO: check out of bounds
+  end
+
+  def test_type_of
+    p_type = JIT::Pointer.new(JIT::Type::INT)
+    assert_equal JIT::Type::INT, p_type.type_of(0)
+    assert_equal JIT::Type::INT, p_type.type_of(1)
+    assert_equal JIT::Type::INT, p_type.type_of(2)
+    assert_equal JIT::Type::INT, p_type.type_of(3)
+    # TODO: check out of bounds
+  end
+
+  def test_instance_bracket
+    p = proc { |f|
+      a_type = JIT::Array.new(JIT::Type::INT, 4)
+      p_type = JIT::Pointer.new(JIT::Type::INT)
+      a = a_type.create(f)
+      ptr = p_type.wrap(a.ptr)
+      f.insn_store_relative(a.ptr, 4, f.const(JIT::Type::INT, 42))
+      f.return ptr[1]
+    }
+    assert_function_result(
+        :result => [ JIT::Type::INT, 42 ],
+        &p)
+  end
+
+  def test_instance_bracket_eq
+    p = proc { |f|
+      a_type = JIT::Array.new(JIT::Type::INT, 4)
+      p_type = JIT::Pointer.new(JIT::Type::INT)
+      a = a_type.create(f)
+      ptr = p_type.wrap(a.ptr)
+      ptr[1] = f.const(JIT::Type::INT, 42)
+      f.return a[1]
+    }
+    assert_function_result(
+        :result => [ JIT::Type::INT, 42 ],
+        &p)
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: ruby-libjit
 version: !ruby/object:Gem::Version 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Paul Brannan
@@ -9,11 +9,16 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-05 00:00:00 -05:00
+date: 2009-12-02 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
-description: A wrapper for the libjit library
+description: |
+  Ruby-libjit is a wrapper for the libjit library.  Libjit is a
+  lightweight library for building just-in-time compilers.  Ruby-libjit
+  includes both a wrapper for libjit and a minimal DSL for building loops
+  and control structures.
+
 email: curlypaul924@gmail.com
 executables: []
 
@@ -30,22 +35,25 @@ files:
 - lib/jit/array.rb
 - lib/jit/function.rb
 - lib/jit/struct.rb
+- lib/jit/pointer.rb
 - lib/jit/value.rb
-- ext/rubypp.rb
 - ext/extconf.rb
-- ext/method_data.c
-- ext/minimal_node.c
+- ext/rubypp.rb
 - ext/jit.c
-- ext/method_data.h
+- ext/minimal_node.c
+- ext/method_data.c
 - ext/minimal_node.h
+- ext/method_data.h
 - ext/rubyjit.h
-- ext/insns.inc.rpp
 - ext/method_data.c.rpp
+- ext/insns.inc.rpp
 - sample/gcd_benchmark.rb
-- sample/fib.rb
 - sample/simple.rb
+- sample/fib.rb
 has_rdoc: true
 homepage: http://ruby-libjit.rubyforge.org
+licenses: []
+
 post_install_message: 
 rdoc_options: []
 
@@ -66,12 +74,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: ruby-libjit
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: A wrapper for the libjit library
 test_files: 
-- test/test_jit_array.rb
-- test/test_jit_function.rb
-- test/test_jit_value.rb
 - test/test_jit_struct.rb
+- test/test_jit_value.rb
+- test/test_jit_function.rb
+- test/test_jit_array.rb
+- test/test_jit_pointer.rb