Merge pull request #65 from sisshiki1969/spec2

Spec2

Author: sisshiki1969

.vscode/launch.json

@@ -12,7 +12,7 @@
         "args": [
           "run",
           "--features",
-          "jit-debug",
+          "jit-log",
           "--bin=monoruby",
           "--package=monoruby",
         ],

Cargo.lock

@@ -36,8 +36,8 @@ emit-cfg = ["dump-bc"]
 clap = { version = "4.5.27", features = ["derive"] }
 rustyline = "15.0.0"
 paste = "1.0.15"
-monoasm_macro = { git = "https://github.com/sisshiki1969/monoasm.git" }
-monoasm = { git = "https://github.com/sisshiki1969/monoasm.git" }
+monoasm_macro = { git = "https://github.com/sisshiki1969/monoasm.git", branch = "rc" }
+monoasm = { git = "https://github.com/sisshiki1969/monoasm.git", branch = "rc" }
 ruruby-parse = { git = "https://github.com/sisshiki1969/ruruby-parse.git" }
 monoruby-attr = { path = "../monoruby_attr" }
 num = "0.4.3"

monoruby/Cargo.toml

@@ -113,7 +113,7 @@ pub(super) fn gen_class_new(
         bb.write_back_callargs_and_dst(ir, callsite);
         ir.stack2reg(recv, GP::Rdi);
         let using_xmm = bb.get_using_xmm();
-        let error = bb.new_error(ir);
+        let error = ir.new_error(bb);
         ir.xmm_save(using_xmm);
         ir.inline(move |gen, _, _| {
             let cached_version = gen.jit.data_i32(-1);

monoruby/src/builtins/class.rs

@@ -68,7 +68,7 @@ fn fiber_yield_inline(
         args, pos_num, dst, ..
     } = *callsite;
     let using_xmm = bb.get_using_xmm();
-    let error = bb.new_error(ir);
+    let error = ir.new_error(bb);
     ir.xmm_save(using_xmm);
     if pos_num == 0 {
         ir.inline(move |gen, _, _| {

monoruby/src/builtins/fiber.rs

@@ -239,7 +239,7 @@ fn hash_index(
             call rax;
         }
     });
-    let error = bb.new_error(ir);
+    let error = ir.new_error(bb);
     ir.handle_error(error);
     bb.rax2acc(ir, callsite.dst);
     true

monoruby/src/builtins/hash.rs

@@ -109,7 +109,7 @@ fn math_sqrt(
         return false;
     }
     let CallSiteInfo { args, dst, .. } = *callsite;
-    let deopt = bb.new_deopt(ir);
+    let deopt = ir.new_deopt(bb);
     let fsrc = bb.fetch_float_for_xmm(ir, args, deopt).enc();
     if let Some(dst) = dst {
         let fret = bb.xmm_write_enc(dst);
@@ -134,7 +134,7 @@ fn math_cos(
         return false;
     }
     let CallSiteInfo { args, dst, .. } = *callsite;
-    let deopt = bb.new_deopt(ir);
+    let deopt = ir.new_deopt(bb);
     let fsrc = bb.fetch_float_for_xmm(ir, args, deopt).enc();
     if let Some(ret) = dst {
         let fret = bb.xmm_write_enc(ret);
@@ -167,7 +167,7 @@ fn math_sin(
         return false;
     }
     let CallSiteInfo { args, dst: ret, .. } = *callsite;
-    let deopt = bb.new_deopt(ir);
+    let deopt = ir.new_deopt(bb);
     let fsrc = bb.fetch_float_for_xmm(ir, args, deopt).enc();
     if let Some(ret) = ret {
         let fret = bb.xmm_write_enc(ret);

monoruby/src/builtins/math.rs

@@ -404,12 +404,12 @@ fn integer_shr(
         return false;
     }
     let CallSiteInfo { dst, args, .. } = *callsite;
-    let deopt = bb.new_deopt(ir);
+    let deopt = ir.new_deopt(bb);
     if let Some(rhs) = bb.is_u8_literal(args) {
         ir.inline(move |gen, _, _| gen.gen_shr_imm(rhs));
     } else {
         bb.fetch_fixnum(ir, args, GP::Rcx, deopt);
-        ir.inline(move |gen, _, labels| gen.gen_shr(labels[deopt]));
+        ir.inline(move |gen, _, labels| gen.gen_shr(&labels[deopt]));
     }
     bb.reg2acc_fixnum(ir, GP::Rdi, dst);
     true
@@ -440,17 +440,17 @@ fn integer_shl(
     let CallSiteInfo {
         dst, args, recv, ..
     } = *callsite;
-    let deopt = bb.new_deopt(ir);
+    let deopt = ir.new_deopt(bb);
     if let Some(rhs) = bb.is_u8_literal(args)
         && rhs < 64
     {
-        ir.inline(move |gen, _, labels| gen.gen_shl_rhs_imm(rhs, labels[deopt]));
+        ir.inline(move |gen, _, labels| gen.gen_shl_rhs_imm(rhs, &labels[deopt]));
     } else if let Some(lhs) = bb.is_fixnum_literal(recv) {
         bb.fetch_fixnum(ir, args, GP::Rcx, deopt);
-        ir.inline(move |gen, _, labels| gen.gen_shl_lhs_imm(lhs, labels[deopt]));
+        ir.inline(move |gen, _, labels| gen.gen_shl_lhs_imm(lhs, &labels[deopt]));
     } else {
         bb.fetch_fixnum(ir, args, GP::Rcx, deopt);
-        ir.inline(move |gen, _, labels| gen.gen_shl(labels[deopt]));
+        ir.inline(move |gen, _, labels| gen.gen_shl(&labels[deopt]));
     }
     bb.reg2acc_fixnum(ir, GP::Rdi, dst);
     true

monoruby/src/builtins/numeric/integer.rs

@@ -22,7 +22,15 @@ pub(super) fn init(globals: &mut Globals) {
         Box::new(object_object_id),
         0,
     );
-    globals.define_builtin_func_with(OBJECT_CLASS, "respond_to?", respond_to, 1, 2, false);
+    globals.define_builtin_inline_func_with(
+        OBJECT_CLASS,
+        "respond_to?",
+        respond_to,
+        Box::new(object_respond_to),
+        1,
+        2,
+        false,
+    );
     globals.define_builtin_func(OBJECT_CLASS, "singleton_class", singleton_class, 0);
     globals.define_builtin_func(OBJECT_CLASS, "to_s", to_s, 0);
     globals.define_builtin_func(OBJECT_CLASS, "inspect", inspect, 0);
@@ -134,11 +142,11 @@ pub fn object_send(
     bb.write_back_callargs_and_dst(ir, callsite);
     bb.writeback_acc(ir);
     let using_xmm = bb.get_using_xmm();
-    let error = bb.new_error(ir);
+    let error = ir.new_error(bb);
     let callid = callsite.id;
     ir.inline(move |gen, store, labels| {
-        let error = labels[error];
-        gen.object_send_inline(callid, store, using_xmm, error, no_splat);
+        let error = &labels[error];
+        gen.object_send_inline(callid, store, using_xmm, &error, no_splat);
     });
     bb.reg2acc(ir, GP::Rax, callsite.dst);
     true
@@ -273,6 +281,40 @@ fn respond_to(_vm: &mut Executor, globals: &mut Globals, lfp: Lfp) -> Result<Val
     }))
 }
 
+fn object_respond_to(
+    bb: &mut BBContext,
+    _: &mut AsmIr,
+    ctx: &JitContext,
+    store: &Store,
+    callsite: &CallSiteInfo,
+    recv_class: ClassId,
+) -> bool {
+    if !callsite.is_simple() {
+        return false;
+    }
+    let CallSiteInfo {
+        dst, args, pos_num, ..
+    } = *callsite;
+    let dst = if let Some(dst) = dst {
+        dst
+    } else {
+        return false;
+    };
+    if pos_num != 1 {
+        return false;
+    }
+    let method_name = if let Some(name) = bb.is_symbol_literal(args) {
+        name
+    } else {
+        return false;
+    };
+    let b = store
+        .check_method_for_class(recv_class, method_name, ctx.class_version())
+        .is_some();
+    bb.def_concrete_value(dst, Value::bool(b));
+    true
+}
+
 ///
 /// ### Object#inspect
 ///

monoruby/src/builtins/object.rs

@@ -180,7 +180,7 @@ impl Bc2 {
 ///
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 #[repr(transparent)]
-struct BytecodePtrBase(std::ptr::NonNull<Bytecode>);
+pub(crate) struct BytecodePtrBase(std::ptr::NonNull<Bytecode>);
 
 impl std::ops::Add<usize> for BytecodePtrBase {
     type Output = BytecodePtr;
@@ -199,7 +199,11 @@ impl std::ops::Add<BcIndex> for BytecodePtrBase {
 }
 
 impl BytecodePtrBase {
-    fn as_ptr(&self) -> *mut Bytecode {
+    pub fn from_bc(bc: &Bytecode) -> Self {
+        Self(std::ptr::NonNull::from(bc))
+    }
+
+    pub fn as_ptr(&self) -> *mut Bytecode {
         self.0.as_ptr()
     }
 }
@@ -212,20 +216,11 @@ impl BytecodePtrBase {
 pub(crate) struct BytecodePtr(std::ptr::NonNull<Bytecode>);
 
 impl std::ops::Sub<BytecodePtrBase> for BytecodePtr {
-    type Output = usize;
-    fn sub(self, rhs: BytecodePtrBase) -> usize {
-        let offset = unsafe { self.as_ptr().offset_from(rhs.as_ptr()) };
-        assert!(offset >= 0, "self:{:?} rhs:{:?}", self, rhs);
-        offset as usize
-    }
-}
-
-impl std::ops::Sub<BytecodePtr> for BytecodePtr {
-    type Output = usize;
-    fn sub(self, rhs: BytecodePtr) -> usize {
+    type Output = BcIndex;
+    fn sub(self, rhs: BytecodePtrBase) -> BcIndex {
         let offset = unsafe { self.as_ptr().offset_from(rhs.as_ptr()) };
         assert!(offset >= 0, "self:{:?} rhs:{:?}", self, rhs);
-        offset as usize
+        BcIndex(offset as u32)
     }
 }
 

monoruby/src/bytecode.rs

@@ -74,10 +74,10 @@ impl BytecodeGen {
             if rescue.is_none() && ensure.is_none() {
                 continue;
             }
-            let start = self.get_pc(info, range.start);
-            let end = self.get_pc(info, range.end);
-            let rescue = rescue.map(|l| self.get_pc(info, l));
-            let ensure = ensure.map(|l| self.get_pc(info, l));
+            let start = self[range.start];
+            let end = self[range.end];
+            let rescue = rescue.map(|l| self[l]);
+            let ensure = ensure.map(|l| self[l]);
             let err_reg = err_reg.map(|reg| self.slot_id(&reg));
             info.exception_push(start..end, rescue, ensure, err_reg);
         }
@@ -93,10 +93,6 @@ impl BytecodeGen {
         Ok(())
     }
 
-    fn get_pc(&self, info: &ISeqInfo, label: Label) -> BytecodePtr {
-        info.get_pc(self[label])
-    }
-
     fn ir_to_bc(&mut self, store: &mut Store) -> Result<(Vec<Bytecode>, Vec<Loc>, BasicBlockInfo)> {
         let mut ops = vec![];
         let mut sourcemap = vec![];