cranelift_ruby 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '039ede96c7d734182f363ea730befc04ae5cd9dd13e2564219e6dd03beae4d64'
-  data.tar.gz: 164e40e024c40bf14df62dad63189a4d428eed20ffcfb13f3c584dc91eb8d586
+  metadata.gz: b8ef6498b6c31260c7279250bfc16f25841a2535ed537f08ba578e744654701e
+  data.tar.gz: ccd764f8cde0e44748c243186dfc7a075c3adb69638b30523d60573e35ad072a
 SHA512:
-  metadata.gz: 81228c2a238389ffa49236b29cb8f3017afbd90f47237d2a03cf966c67b6657ecd94538f0ce0000779d0779b1d1ca995fd4120f4628641fdb54f542e94ab2f13
-  data.tar.gz: f57c3c484724faf31e3738311cdfaa3bcf3f2b3dcdf6f8bed1a77e53724b6040689fd12c615325da440cb74cfbfc9ad1746c9828fb17150058811f9efcb340ff
+  metadata.gz: f8e3e5ed4c71bc2a638cd1e78e590d97dedcc9fe191e63f47668865d2177608af4726bc6a85b5af1e79f0cee80a2601254a4fad018acc11aaa941b7504dad0eb
+  data.tar.gz: 51ee94425d29b79fefe238e45df276c986b6d7196c5cd643a648aaf4b4b04f7ad62fae70ebcd00bc8b6df79e2304fb989c82d455d16ee93f792aa1ab817a6c87

data/lib/cranelift_ruby/version.rb

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

data/src/lib.rs

@@ -4,8 +4,8 @@ extern crate rutie;
 #[macro_use]
 extern crate lazy_static;
 
+use std::collections::HashMap;
 use std::convert::TryInto;
-use std::mem;
 use std::num::TryFromIntError;
 
 use cranelift::codegen::binemit::{NullStackMapSink, NullTrapSink};
@@ -15,19 +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::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};
+use rutie::{
+    AnyException, AnyObject, Array, Class, Exception, Integer, NilClass, Object, Proc, RString,
+    Symbol, VM,
+};
 class!(Cranelift);
 
 pub struct Builder {
     pub module: JITModule,
-    pub verbose: bool
+    pub funcs_sizes: HashMap<u32, u32>,
 }
 
 impl Builder {
-    fn new(verbose: bool) -> Result<Self> {
+    fn new() -> 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.
@@ -37,7 +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
+            funcs_sizes: HashMap::new(),
         })
     }
 }
@@ -46,36 +46,6 @@ 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,
@@ -91,15 +61,24 @@ 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();
         let signature = signature.map_err(|e| VM::raise_ex(e)).unwrap();
         let signature = signature.get_data(&*SIGNATURE_WRAPPER);
         let callback = callback.map_err(|e| VM::raise_ex(e)).unwrap();
-        let func_id = make_function_impl(name.to_str(), signature, callback, builder)
+        let (func_id, func_size) = make_function_impl(name.to_str(), signature, callback, builder)
             .map_err(|e| VM::raise_ex(e))
             .unwrap();
+        builder.funcs_sizes.insert(func_id, func_size);
         Integer::new(func_id.into())
     },
     fn finalize() -> NilClass {
@@ -122,6 +101,30 @@ methods!(
             .unwrap();
         let func_id = FuncId::new(func_id);
         Integer::new(builder.module.get_finalized_function(func_id) as i64)
+    },
+    fn get_function_size(func_id: Integer) -> Integer {
+        let builder = itself.get_data_mut(&*BUILDER_WRAPPER);
+        let func_id = func_id.map_err(|e| VM::raise_ex(e)).unwrap();
+        let func_id = func_id
+            .to_i64()
+            .try_into()
+            .map_err(|_e| {
+                VM::raise_ex(AnyException::new(
+                    "StandardError",
+                    Some("Could create function id due to bad conversion"),
+                ))
+            })
+            .unwrap();
+        Integer::new(
+            (*builder.funcs_sizes.get(&func_id).unwrap_or_else(|| {
+                VM::raise_ex(AnyException::new(
+                    "StandardError",
+                    Some("Could create function id due to bad conversion"),
+                ));
+                &0
+            }))
+            .into(),
+        )
     }
 );
 
@@ -168,7 +171,7 @@ fn make_function_impl(
     signature: &Signature,
     callback: Proc,
     builder: &mut Builder,
-) -> Result<u32, AnyException> {
+) -> Result<(u32, u32), AnyException> {
     let func = builder
         .module
         .declare_function(name, Linkage::Local, &signature)
@@ -177,7 +180,6 @@ 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(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")
@@ -185,15 +187,12 @@ fn make_function_impl(
     callback.call(&[cranelift_bcx]);
     let mut trap_sink = NullTrapSink {};
     let mut stack_map_sink = NullStackMapSink {};
-    builder
+    let f = builder
         .module
         .define_function(func, &mut ctx, &mut trap_sink, &mut stack_map_sink)
         .map_err(|e| AnyException::new("StandardError", Some(&format!("{:?}", e))))?;
-    if builder.verbose {
-        println!("\n{}", ctx.func.display(None).to_string());
-        println!("{}\n", ctx.mach_compile_result.unwrap().disasm.unwrap());
-    }
-    Ok(func.as_u32())
+    // println!("code: {}", ctx.mach_compile_result.unwrap().disasm.unwrap());
+    Ok((func.as_u32(), f.size))
 }
 
 wrappable_struct!(Signature, SignatureWrapper, SIGNATURE_WRAPPER);
@@ -276,30 +275,36 @@ methods!(
         Class::from_existing("CraneliftRuby")
             .get_nested_class("SigRef")
             .wrap_data(sigref, &*SIGREF_WRAPPER)
-    }
+    },
     fn call_indirect(sigref: AnyObject, callee: Integer, args: Array) -> Integer {
         let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
 
         let sigref = sigref.map_err(|e| VM::raise_ex(e)).unwrap();
         let sigref = sigref.get_data(&*SIGREF_WRAPPER);
         let callee = callee.map_err(|e| VM::raise_ex(e)).unwrap();
-        let callee = from_integer_to_value(callee).map_err(|e| VM::raise_ex(e)).unwrap();
+        let callee = from_integer_to_value(callee)
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
         let args = args.map_err(|e| VM::raise_ex(e)).unwrap();
-        let args = from_array_to_values(args).map_err(|e| VM::raise_ex(e)).unwrap();
+        let args = from_array_to_values(args)
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
         let res = bcx.ins().call_indirect(*sigref, callee, &args);
         Integer::new(res.as_u32().into())
-    }
+    },
     fn inst_results(inst: Integer) -> Array {
         let mut result = Array::new();
         let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
         let inst = inst.map_err(|e| VM::raise_ex(e)).unwrap();
-        let inst = from_integer_to_inst(inst).map_err(|e| VM::raise_ex(e)).unwrap();
+        let inst = from_integer_to_inst(inst)
+            .map_err(|e| VM::raise_ex(e))
+            .unwrap();
         let values = bcx.inst_results(inst);
         for value in values {
             result.push(Integer::new(value.as_u32().into()));
         }
         result
-    }
+    },
     fn iconst(ty: Symbol, value: Integer) -> Integer {
         let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
         let ty = ty.map_err(|e| VM::raise_ex(e)).unwrap();
@@ -574,7 +579,6 @@ fn from_array_to_values(array: Array) -> Result<Vec<Value>, AnyException> {
 wrappable_struct!(Variable, VariableWrapper, VARIABLE_WRAPPER);
 wrappable_struct!(SigRef, SigRefWrapper, SIGREF_WRAPPER);
 
-
 class!(CraneliftVariable);
 
 methods!(

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cranelift_ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Marco Concetto Rudilosso