cranelift_ruby 0.1.4 → 0.1.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
checksums.yaml CHANGED
@@ -1,7 +1,7 @@
1
1
  ---
2
2
  SHA256:
3
- metadata.gz: '039ede96c7d734182f363ea730befc04ae5cd9dd13e2564219e6dd03beae4d64'
4
- data.tar.gz: 164e40e024c40bf14df62dad63189a4d428eed20ffcfb13f3c584dc91eb8d586
3
+ metadata.gz: b8ef6498b6c31260c7279250bfc16f25841a2535ed537f08ba578e744654701e
4
+ data.tar.gz: ccd764f8cde0e44748c243186dfc7a075c3adb69638b30523d60573e35ad072a
5
5
  SHA512:
6
- metadata.gz: 81228c2a238389ffa49236b29cb8f3017afbd90f47237d2a03cf966c67b6657ecd94538f0ce0000779d0779b1d1ca995fd4120f4628641fdb54f542e94ab2f13
7
- data.tar.gz: f57c3c484724faf31e3738311cdfaa3bcf3f2b3dcdf6f8bed1a77e53724b6040689fd12c615325da440cb74cfbfc9ad1746c9828fb17150058811f9efcb340ff
6
+ metadata.gz: f8e3e5ed4c71bc2a638cd1e78e590d97dedcc9fe191e63f47668865d2177608af4726bc6a85b5af1e79f0cee80a2601254a4fad018acc11aaa941b7504dad0eb
7
+ data.tar.gz: 51ee94425d29b79fefe238e45df276c986b6d7196c5cd643a648aaf4b4b04f7ad62fae70ebcd00bc8b6df79e2304fb989c82d455d16ee93f792aa1ab817a6c87
@@ -1,3 +1,3 @@
1
1
  module CraneliftRuby
2
- VERSION = "0.1.4"
2
+ VERSION = "0.1.5"
3
3
  end
data/src/lib.rs CHANGED
@@ -4,8 +4,8 @@ extern crate rutie;
4
4
  #[macro_use]
5
5
  extern crate lazy_static;
6
6
 
7
+ use std::collections::HashMap;
7
8
  use std::convert::TryInto;
8
- use std::mem;
9
9
  use std::num::TryFromIntError;
10
10
 
11
11
  use cranelift::codegen::binemit::{NullStackMapSink, NullTrapSink};
@@ -15,19 +15,19 @@ use cranelift::prelude::*;
15
15
  use cranelift_jit::{JITBuilder, JITModule};
16
16
  use cranelift_module::{default_libcall_names, FuncId, Linkage, Module};
17
17
  use eyre::{eyre, Result};
18
- use rutie::rubysys::class;
19
- use rutie::types::Argc;
20
- use rutie::util::str_to_cstring;
21
- use rutie::{AnyException, AnyObject, Array, Boolean, Class, Exception, Integer, NilClass, Object, Proc, RString, Symbol, VM};
18
+ use rutie::{
19
+ AnyException, AnyObject, Array, Class, Exception, Integer, NilClass, Object, Proc, RString,
20
+ Symbol, VM,
21
+ };
22
22
  class!(Cranelift);
23
23
 
24
24
  pub struct Builder {
25
25
  pub module: JITModule,
26
- pub verbose: bool
26
+ pub funcs_sizes: HashMap<u32, u32>,
27
27
  }
28
28
 
29
29
  impl Builder {
30
- fn new(verbose: bool) -> Result<Self> {
30
+ fn new() -> Result<Self> {
31
31
  let mut flag_builder = settings::builder();
32
32
  flag_builder.set("use_colocated_libcalls", "false")?;
33
33
  // FIXME set back to true once the x64 backend supports it.
@@ -37,7 +37,7 @@ impl Builder {
37
37
  let isa = isa_builder.finish(settings::Flags::new(flag_builder));
38
38
  Ok(Self {
39
39
  module: JITModule::new(JITBuilder::with_isa(isa, default_libcall_names())),
40
- verbose: verbose
40
+ funcs_sizes: HashMap::new(),
41
41
  })
42
42
  }
43
43
  }
@@ -46,36 +46,6 @@ wrappable_struct!(Builder, BuilderWrapper, BUILDER_WRAPPER);
46
46
 
47
47
  class!(CraneliftBuilder);
48
48
 
49
- pub extern fn cranelift_builder_new(argc: Argc, argv: *const AnyObject, _rtself: AnyObject) -> AnyObject {
50
- let args = rutie::types::Value::from(0);
51
-
52
- unsafe {
53
- let p_argv: *const rutie::types::Value = mem::transmute(argv);
54
-
55
- class::rb_scan_args(
56
- argc,
57
- p_argv,
58
- str_to_cstring("*").as_ptr(),
59
- &args
60
- )
61
- };
62
-
63
- let arguments = Array::from(args);
64
- let verbose = {
65
- if arguments.length() == 1 {
66
- arguments.at(0).try_convert_to::<Boolean>().map_err(|e| VM::raise_ex(e)).unwrap().to_bool()
67
- } else {
68
- false
69
- }
70
- };
71
- let builder = Builder::new(verbose)
72
- .map_err(|e| VM::raise_ex(AnyException::new("StandardError", Some(&e.to_string()))))
73
- .unwrap();
74
- Class::from_existing("CraneliftRuby")
75
- .get_nested_class("CraneliftBuilder")
76
- .wrap_data(builder, &*BUILDER_WRAPPER)
77
- }
78
-
79
49
  methods!(
80
50
  CraneliftBuilder,
81
51
  itself,
@@ -91,15 +61,24 @@ methods!(
91
61
  .get_nested_class("Signature")
92
62
  .wrap_data(sig, &*SIGNATURE_WRAPPER)
93
63
  },
64
+ fn cranelift_builder_new() -> AnyObject {
65
+ let builder = Builder::new()
66
+ .map_err(|e| VM::raise_ex(AnyException::new("StandardError", Some(&e.to_string()))))
67
+ .unwrap();
68
+ Class::from_existing("CraneliftRuby")
69
+ .get_nested_class("CraneliftBuilder")
70
+ .wrap_data(builder, &*BUILDER_WRAPPER)
71
+ },
94
72
  fn make_function(name: RString, signature: AnyObject, callback: Proc) -> Integer {
95
73
  let builder = itself.get_data_mut(&*BUILDER_WRAPPER);
96
74
  let name = name.map_err(|e| VM::raise_ex(e)).unwrap();
97
75
  let signature = signature.map_err(|e| VM::raise_ex(e)).unwrap();
98
76
  let signature = signature.get_data(&*SIGNATURE_WRAPPER);
99
77
  let callback = callback.map_err(|e| VM::raise_ex(e)).unwrap();
100
- let func_id = make_function_impl(name.to_str(), signature, callback, builder)
78
+ let (func_id, func_size) = make_function_impl(name.to_str(), signature, callback, builder)
101
79
  .map_err(|e| VM::raise_ex(e))
102
80
  .unwrap();
81
+ builder.funcs_sizes.insert(func_id, func_size);
103
82
  Integer::new(func_id.into())
104
83
  },
105
84
  fn finalize() -> NilClass {
@@ -122,6 +101,30 @@ methods!(
122
101
  .unwrap();
123
102
  let func_id = FuncId::new(func_id);
124
103
  Integer::new(builder.module.get_finalized_function(func_id) as i64)
104
+ },
105
+ fn get_function_size(func_id: Integer) -> Integer {
106
+ let builder = itself.get_data_mut(&*BUILDER_WRAPPER);
107
+ let func_id = func_id.map_err(|e| VM::raise_ex(e)).unwrap();
108
+ let func_id = func_id
109
+ .to_i64()
110
+ .try_into()
111
+ .map_err(|_e| {
112
+ VM::raise_ex(AnyException::new(
113
+ "StandardError",
114
+ Some("Could create function id due to bad conversion"),
115
+ ))
116
+ })
117
+ .unwrap();
118
+ Integer::new(
119
+ (*builder.funcs_sizes.get(&func_id).unwrap_or_else(|| {
120
+ VM::raise_ex(AnyException::new(
121
+ "StandardError",
122
+ Some("Could create function id due to bad conversion"),
123
+ ));
124
+ &0
125
+ }))
126
+ .into(),
127
+ )
125
128
  }
126
129
  );
127
130
 
@@ -168,7 +171,7 @@ fn make_function_impl(
168
171
  signature: &Signature,
169
172
  callback: Proc,
170
173
  builder: &mut Builder,
171
- ) -> Result<u32, AnyException> {
174
+ ) -> Result<(u32, u32), AnyException> {
172
175
  let func = builder
173
176
  .module
174
177
  .declare_function(name, Linkage::Local, &signature)
@@ -177,7 +180,6 @@ fn make_function_impl(
177
180
  let mut func_ctx = FunctionBuilderContext::new();
178
181
  ctx.func.signature = signature.clone();
179
182
  ctx.func.name = ExternalName::user(0, func.as_u32());
180
- ctx.set_disasm(builder.verbose);
181
183
  let bcx: FunctionBuilder = FunctionBuilder::new(&mut ctx.func, &mut func_ctx);
182
184
  let cranelift_bcx: AnyObject = Class::from_existing("CraneliftRuby")
183
185
  .get_nested_class("CraneliftFunctionBuilder")
@@ -185,15 +187,12 @@ fn make_function_impl(
185
187
  callback.call(&[cranelift_bcx]);
186
188
  let mut trap_sink = NullTrapSink {};
187
189
  let mut stack_map_sink = NullStackMapSink {};
188
- builder
190
+ let f = builder
189
191
  .module
190
192
  .define_function(func, &mut ctx, &mut trap_sink, &mut stack_map_sink)
191
193
  .map_err(|e| AnyException::new("StandardError", Some(&format!("{:?}", e))))?;
192
- if builder.verbose {
193
- println!("\n{}", ctx.func.display(None).to_string());
194
- println!("{}\n", ctx.mach_compile_result.unwrap().disasm.unwrap());
195
- }
196
- Ok(func.as_u32())
194
+ // println!("code: {}", ctx.mach_compile_result.unwrap().disasm.unwrap());
195
+ Ok((func.as_u32(), f.size))
197
196
  }
198
197
 
199
198
  wrappable_struct!(Signature, SignatureWrapper, SIGNATURE_WRAPPER);
@@ -276,30 +275,36 @@ methods!(
276
275
  Class::from_existing("CraneliftRuby")
277
276
  .get_nested_class("SigRef")
278
277
  .wrap_data(sigref, &*SIGREF_WRAPPER)
279
- }
278
+ },
280
279
  fn call_indirect(sigref: AnyObject, callee: Integer, args: Array) -> Integer {
281
280
  let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
282
281
 
283
282
  let sigref = sigref.map_err(|e| VM::raise_ex(e)).unwrap();
284
283
  let sigref = sigref.get_data(&*SIGREF_WRAPPER);
285
284
  let callee = callee.map_err(|e| VM::raise_ex(e)).unwrap();
286
- let callee = from_integer_to_value(callee).map_err(|e| VM::raise_ex(e)).unwrap();
285
+ let callee = from_integer_to_value(callee)
286
+ .map_err(|e| VM::raise_ex(e))
287
+ .unwrap();
287
288
  let args = args.map_err(|e| VM::raise_ex(e)).unwrap();
288
- let args = from_array_to_values(args).map_err(|e| VM::raise_ex(e)).unwrap();
289
+ let args = from_array_to_values(args)
290
+ .map_err(|e| VM::raise_ex(e))
291
+ .unwrap();
289
292
  let res = bcx.ins().call_indirect(*sigref, callee, &args);
290
293
  Integer::new(res.as_u32().into())
291
- }
294
+ },
292
295
  fn inst_results(inst: Integer) -> Array {
293
296
  let mut result = Array::new();
294
297
  let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
295
298
  let inst = inst.map_err(|e| VM::raise_ex(e)).unwrap();
296
- let inst = from_integer_to_inst(inst).map_err(|e| VM::raise_ex(e)).unwrap();
299
+ let inst = from_integer_to_inst(inst)
300
+ .map_err(|e| VM::raise_ex(e))
301
+ .unwrap();
297
302
  let values = bcx.inst_results(inst);
298
303
  for value in values {
299
304
  result.push(Integer::new(value.as_u32().into()));
300
305
  }
301
306
  result
302
- }
307
+ },
303
308
  fn iconst(ty: Symbol, value: Integer) -> Integer {
304
309
  let bcx = itself.get_data_mut(&*FUNCTION_BUILDER_WRAPPER);
305
310
  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> {
574
579
  wrappable_struct!(Variable, VariableWrapper, VARIABLE_WRAPPER);
575
580
  wrappable_struct!(SigRef, SigRefWrapper, SIGREF_WRAPPER);
576
581
 
577
-
578
582
  class!(CraneliftVariable);
579
583
 
580
584
  methods!(
metadata CHANGED
@@ -1,7 +1,7 @@
1
1
  --- !ruby/object:Gem::Specification
2
2
  name: cranelift_ruby
3
3
  version: !ruby/object:Gem::Version
4
- version: 0.1.4
4
+ version: 0.1.5
5
5
  platform: ruby
6
6
  authors:
7
7
  - Marco Concetto Rudilosso