cranelift_ruby 0.1.0 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d1487b62468b109e4245cee90074f2372c2cb7abeecf33275bdce071fef1e220
-  data.tar.gz: 91d1a096961545faf0ba4da70a19a58b1a395c4b0419303ce6abafbd8ee49a80
+  metadata.gz: '039ede96c7d734182f363ea730befc04ae5cd9dd13e2564219e6dd03beae4d64'
+  data.tar.gz: 164e40e024c40bf14df62dad63189a4d428eed20ffcfb13f3c584dc91eb8d586
 SHA512:
-  metadata.gz: b56586435590db7e090b14b372bceeb32fd9c41955a4528dea99d6ce77413278d150b4c80e681a843c50d29cb7573e91f199ed2323f4611b5c92d13fc173b669
-  data.tar.gz: ce719fe18e79a14de52bab14745ceeae9cda0cadf9f9ac597cc8792dc729a7c059cc3039d93f7b92fc831abcf55b9406f2dbad2eabadfd789d059d28a7ec459c
+  metadata.gz: 81228c2a238389ffa49236b29cb8f3017afbd90f47237d2a03cf966c67b6657ecd94538f0ce0000779d0779b1d1ca995fd4120f4628641fdb54f542e94ab2f13
+  data.tar.gz: f57c3c484724faf31e3738311cdfaa3bcf3f2b3dcdf6f8bed1a77e53724b6040689fd12c615325da440cb74cfbfc9ad1746c9828fb17150058811f9efcb340ff

data/Rakefile

@@ -34,4 +34,4 @@ Rake::TestTask.new(test_clean: %i[tidy_up bundle_install build_lib]) do |t|
   t.test_files = FileList["test/**/*_test.rb"]
 end
 
-task default: :test_clean
+task default: :build_lib

data/lib/cranelift_ruby/version.rb

@@ -1,3 +1,3 @@
 module CraneliftRuby
-  VERSION = "0.1.0"
-end
+  VERSION = "0.1.4"
+end

data/src/lib.rs

@@ -5,6 +5,7 @@ extern crate rutie;
 extern crate lazy_static;
 
 use std::convert::TryInto;
+use std::mem;
 use std::num::TryFromIntError;
 
 use cranelift::codegen::binemit::{NullStackMapSink, NullTrapSink};
@@ -14,18 +15,19 @@ use cranelift::prelude::*;
 use cranelift_jit::{JITBuilder, JITModule};
 use cranelift_module::{default_libcall_names, FuncId, Linkage, Module};
 use eyre::{eyre, Result};
-use rutie::{
-    AnyException, AnyObject, Array, Class, Exception, Integer, NilClass, Object, Proc, RString,
-    Symbol, VM,
-};
+use rutie::rubysys::class;
+use rutie::types::Argc;
+use rutie::util::str_to_cstring;
+use rutie::{AnyException, AnyObject, Array, Boolean, Class, Exception, Integer, NilClass, Object, Proc, RString, Symbol, VM};
 class!(Cranelift);
 
 pub struct Builder {
     pub module: JITModule,
+    pub verbose: bool
 }
 
 impl Builder {
-    fn new() -> Result<Self> {
+    fn new(verbose: bool) -> Result<Self> {
         let mut flag_builder = settings::builder();
         flag_builder.set("use_colocated_libcalls", "false")?;
         // FIXME set back to true once the x64 backend supports it.
@@ -35,6 +37,7 @@ impl Builder {
         let isa = isa_builder.finish(settings::Flags::new(flag_builder));
         Ok(Self {
             module: JITModule::new(JITBuilder::with_isa(isa, default_libcall_names())),
+            verbose: verbose
         })
     }
 }
@@ -43,6 +46,36 @@ wrappable_struct!(Builder, BuilderWrapper, BUILDER_WRAPPER);
 
 class!(CraneliftBuilder);
 
+pub extern fn cranelift_builder_new(argc: Argc, argv: *const AnyObject, _rtself: AnyObject) -> AnyObject {
+    let args = rutie::types::Value::from(0);
+
+    unsafe {
+        let p_argv: *const rutie::types::Value = mem::transmute(argv);
+
+        class::rb_scan_args(
+            argc,
+            p_argv,
+            str_to_cstring("*").as_ptr(),
+            &args
+        )
+    };
+
+    let arguments = Array::from(args);
+    let verbose = {
+        if arguments.length() == 1 {
+            arguments.at(0).try_convert_to::<Boolean>().map_err(|e| VM::raise_ex(e)).unwrap().to_bool()
+        } else {
+            false
+        }
+    };
+    let builder = Builder::new(verbose)
+            .map_err(|e| VM::raise_ex(AnyException::new("StandardError", Some(&e.to_string()))))
+            .unwrap();
+    Class::from_existing("CraneliftRuby")
+        .get_nested_class("CraneliftBuilder")
+        .wrap_data(builder, &*BUILDER_WRAPPER)
+}
+
 methods!(
     CraneliftBuilder,
     itself,
@@ -58,14 +91,6 @@ methods!(
             .get_nested_class("Signature")
             .wrap_data(sig, &*SIGNATURE_WRAPPER)
     },
-    fn cranelift_builder_new() -> AnyObject {
-        let builder = Builder::new()
-            .map_err(|e| VM::raise_ex(AnyException::new("StandardError", Some(&e.to_string()))))
-            .unwrap();
-        Class::from_existing("CraneliftRuby")
-            .get_nested_class("CraneliftBuilder")
-            .wrap_data(builder, &*BUILDER_WRAPPER)
-    },
     fn make_function(name: RString, signature: AnyObject, callback: Proc) -> Integer {
         let builder = itself.get_data_mut(&*BUILDER_WRAPPER);
         let name = name.map_err(|e| VM::raise_ex(e)).unwrap();
@@ -152,7 +177,7 @@ fn make_function_impl(
     let mut func_ctx = FunctionBuilderContext::new();
     ctx.func.signature = signature.clone();
     ctx.func.name = ExternalName::user(0, func.as_u32());
-    // ctx.set_disasm(true);
+    ctx.set_disasm(builder.verbose);
     let bcx: FunctionBuilder = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
     let cranelift_bcx: AnyObject = Class::from_existing("CraneliftRuby")
         .get_nested_class("CraneliftFunctionBuilder")
@@ -160,12 +185,14 @@ fn make_function_impl(
     callback.call(&[cranelift_bcx]);
     let mut trap_sink = NullTrapSink {};
     let mut stack_map_sink = NullStackMapSink {};
-    // println!("{}", ctx.func.display(None).to_string());
     builder
         .module
         .define_function(func, &mut ctx, &mut trap_sink, &mut stack_map_sink)
         .map_err(|e| AnyException::new("StandardError", Some(&format!("{:?}", e))))?;
-    // println!("code: {}", ctx.mach_compile_result.unwrap().disasm.unwrap());
+    if builder.verbose {
+        println!("\n{}", ctx.func.display(None).to_string());
+        println!("{}\n", ctx.mach_compile_result.unwrap().disasm.unwrap());
+    }
     Ok(func.as_u32())
 }
 
@@ -343,6 +370,34 @@ methods!(
         let res = bcx.ins().iadd(x, y);
         Integer::new(res.as_u32().into())
     },
+    fn band(x: Integer, y: Integer) -> Integer {
+        let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
+        let x = x.map_err(|e| VM::raise_ex(e)).unwrap();
+        let x = from_integer_to_value(x)
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
+        let y = y.map_err(|e| VM::raise_ex(e)).unwrap();
+        let y = from_integer_to_value(y)
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
+
+        let res = bcx.ins().band(x, y);
+        Integer::new(res.as_u32().into())
+    },
+    fn bor(x: Integer, y: Integer) -> Integer {
+        let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
+        let x = x.map_err(|e| VM::raise_ex(e)).unwrap();
+        let x = from_integer_to_value(x)
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
+        let y = y.map_err(|e| VM::raise_ex(e)).unwrap();
+        let y = from_integer_to_value(y)
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
+
+        let res = bcx.ins().bor(x, y);
+        Integer::new(res.as_u32().into())
+    },
     fn return_(values: Array) -> NilClass {
         let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
         let values = values.map_err(|e| VM::raise_ex(e)).unwrap();
@@ -591,9 +646,12 @@ pub extern "C" fn Init_cranelift_ruby() {
                 klass.def("def_var", def_var);
                 klass.def("use_var", use_var);
                 klass.def("icmp", icmp);
+                klass.def("select", select);
                 klass.def("import_signature", import_signature);
                 klass.def("call_indirect", call_indirect);
                 klass.def("inst_results", inst_results);
+                klass.def("band", band);
+                klass.def("bor", bor);
             });
     });
 }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cranelift_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.4
 platform: ruby
 authors:
 - Marco Concetto Rudilosso
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-23 00:00:00.000000000 Z
+date: 2021-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rutie