cranelift_ruby 0.1.2 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9bfad5344bffc02e6f40ed9ce5629cf507ac4d6136fcc2d3d863d3ebbe281df3
-  data.tar.gz: b78bf7c8f28ea44d30b6f8a2c872d5a48e8e59e3528c1269da1bde2e3015e9f5
+  metadata.gz: c0a7e11a371b647924f89079254b3018b63a946ad319b5c3cb1819d7ba1452e8
+  data.tar.gz: 7dca58aaf433bb0d25b2c2bfd0a8366386d2fca841f8b315b84e02fb971e8939
 SHA512:
-  metadata.gz: 21e94193a3c2f0d0abe7e153418f70b52b145ca96e105a25c8584950422b5fa1e1e082727250552a71b602f48b391a52c438d3dbee0041c92a79d62d2eefc42e
-  data.tar.gz: 58b8ae7bf977fdcb6218437de71c4fc13e0a98af2a10b9401c98e80423fc5359912d2310f3dda68cb26e879c617c06ff91ee2c4fa91ec74130bf520cfd6dc8df
+  metadata.gz: 8dba879750f03825db2740ea107b142dab1b2548263fc45d8799130187ed2afb17af7619cfdb98075491e71c90ddf2b0ac8a1bd90e482ab7d98dc0c9bc750b9c
+  data.tar.gz: 948ff5a8b37ac31513bc001e77396a41072eaff186536cffda10cde2d9dffac3f6726abdae681322a81de1e0e30a3734f747a9fe2dce2e1b78aa6ac3083aa7f3

data/lib/cranelift_ruby/version.rb

@@ -1,3 +1,3 @@
 module CraneliftRuby
-  VERSION = "0.1.2"
+  VERSION = "0.1.6"
 end

data/src/lib.rs

@@ -4,6 +4,7 @@ extern crate rutie;
 #[macro_use]
 extern crate lazy_static;
 
+use std::collections::HashMap;
 use std::convert::TryInto;
 use std::num::TryFromIntError;
 
@@ -22,6 +23,7 @@ class!(Cranelift);
 
 pub struct Builder {
     pub module: JITModule,
+    pub funcs_sizes: HashMap<u32, u32>,
 }
 
 impl Builder {
@@ -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())),
+            funcs_sizes: HashMap::new(),
         })
     }
 }
@@ -72,9 +75,10 @@ methods!(
         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 {
@@ -97,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(),
+        )
     }
 );
 
@@ -143,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)
@@ -152,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(true);
     let bcx: FunctionBuilder = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
     let cranelift_bcx: AnyObject = Class::from_existing("CraneliftRuby")
         .get_nested_class("CraneliftFunctionBuilder")
@@ -160,13 +187,12 @@ 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
+    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))))?;
     // println!("code: {}", ctx.mach_compile_result.unwrap().disasm.unwrap());
-    Ok(func.as_u32())
+    Ok((func.as_u32(), f.size))
 }
 
 wrappable_struct!(Signature, SignatureWrapper, SIGNATURE_WRAPPER);
@@ -249,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();
@@ -343,6 +375,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();
@@ -519,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!(
@@ -558,6 +617,7 @@ pub extern "C" fn Init_cranelift_ruby() {
                 klass.def("make_function", make_function);
                 klass.def("finalize", finalize);
                 klass.def("get_function_pointer", get_function_pointer);
+                klass.def("get_function_size", get_function_size);
             });
         itself.define_nested_class("Signature", Some(&data_class));
         itself.define_nested_class("SigRef", Some(&data_class));
@@ -595,6 +655,8 @@ pub extern "C" fn Init_cranelift_ruby() {
                 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.2
+  version: 0.1.6
 platform: ruby
 authors:
 - Marco Concetto Rudilosso
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-07-25 00:00:00.000000000 Z
+date: 2021-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rutie