Strength reduce to CCall for sends landing in simple C methods

A new optimization pass. Also:
- Printing for `Insn::CCall`
- Wrap `ID` and add convenience method for printing, replacing calls to rb_id2name()

Author: XrXr

test/ruby/test_zjit.rb

@@ -9,6 +9,14 @@
 return unless JITSupport.zjit_supported?
 
 class TestZJIT < Test::Unit::TestCase
+  def test_call_itself
+    assert_compiles '42', <<~RUBY, call_threshold: 2
+      def test = 42.itself
+      test
+      test
+    RUBY
+  end
+
   def test_nil
     assert_compiles 'nil', %q{
       def test = nil

zjit/bindgen/src/main.rs

@@ -225,9 +225,9 @@ fn main() {
         .allowlist_function("rb_intern")
         .allowlist_function("rb_intern2")
         .allowlist_function("rb_id2sym")
-        .allowlist_function("rb_id2name")
         .allowlist_function("rb_sym2id")
         .allowlist_function("rb_str_intern")
+        .allowlist_function("rb_id2str")
 
         // From internal/numeric.h
         .allowlist_function("rb_fix_aref")
@@ -470,8 +470,9 @@ fn main() {
         .allowlist_function("rb_ec_stack_check")
         .allowlist_function("rb_vm_top_self")
 
-        // We define VALUE manually, don't import it
+        // We define these manually, don't import them
         .blocklist_type("VALUE")
+        .blocklist_type("ID")
 
         // From iseq.h
         .opaque_type("rb_iseq_t")

zjit/src/codegen.rs

@@ -203,6 +203,7 @@ fn gen_insn(jit: &mut JITState, asm: &mut Assembler, function: &Function, insn_i
         Insn::GuardType { val, guard_type, state } => gen_guard_type(asm, opnd!(val), *guard_type, &function.frame_state(*state))?,
         Insn::GuardBitEquals { val, expected, state } => gen_guard_bit_equals(asm, opnd!(val), *expected, &function.frame_state(*state))?,
         Insn::PatchPoint(_) => return Some(()), // For now, rb_zjit_bop_redefined() panics. TODO: leave a patch point and fix rb_zjit_bop_redefined()
+        Insn::CCall { cfun, args, name: _ } => gen_ccall(jit, asm, *cfun, args)?,
         _ => {
             debug!("ZJIT: gen_function: unexpected insn {:?}", insn);
             return None;
@@ -215,6 +216,17 @@ fn gen_insn(jit: &mut JITState, asm: &mut Assembler, function: &Function, insn_i
     Some(())
 }
 
+/// Lowering for [`Insn::CCall`]. This is a low-level raw call that doesn't know
+/// anything about the callee, so handling for e.g. GC safety is dealt with elsewhere.
+fn gen_ccall(jit: &mut JITState, asm: &mut Assembler, cfun: *const u8, args: &[InsnId]) -> Option<lir::Opnd> {
+    let mut lir_args = Vec::with_capacity(args.len());
+    for &arg in args {
+        lir_args.push(jit.get_opnd(arg)?);
+    }
+
+    Some(asm.ccall(cfun, lir_args))
+}
+
 /// Compile an interpreter entry block to be inserted into an ISEQ
 fn gen_entry_prologue(iseq: IseqPtr, asm: &mut Assembler) {
     asm_comment!(asm, "ZJIT entry point: {}", iseq_get_location(iseq, 0));

zjit/src/cruby.rs

@@ -250,6 +250,12 @@ pub struct rb_iseq_t {
 #[repr(transparent)] // same size and alignment as simply `usize`
 pub struct VALUE(pub usize);
 
+/// An interned string. See [ids] and methods this type.
+/// `0` is a sentinal value for IDs.
+#[repr(transparent)]
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub struct ID(pub ::std::os::raw::c_ulong);
+
 /// Pointer to an ISEQ
 pub type IseqPtr = *const rb_iseq_t;
 
@@ -455,6 +461,18 @@ impl VALUE {
         }
     }
 
+    /// Borrow the string contents of `self`. Rust unsafe because of possible mutation and GC
+    /// interactions.
+    pub unsafe fn as_rstring_byte_slice<'a>(self) -> Option<&'a [u8]> {
+        if !unsafe { RB_TYPE_P(self, RUBY_T_STRING) } {
+            None
+        } else {
+            let str_ptr = unsafe { rb_RSTRING_PTR(self) } as *const u8;
+            let str_len: usize = unsafe { rb_RSTRING_LEN(self) }.try_into().ok()?;
+            Some(unsafe { std::slice::from_raw_parts(str_ptr, str_len) })
+        }
+    }
+
     pub fn is_frozen(self) -> bool {
         unsafe { rb_obj_frozen_p(self) != VALUE(0) }
     }
@@ -637,6 +655,28 @@ impl From<VALUE> for u16 {
     }
 }
 
+impl ID {
+    // Get a debug representation of the contents of the ID. Since `str` is UTF-8
+    // and IDs have encodings that are not, this is a lossy representation.
+    pub fn contents_lossy(&self) -> std::borrow::Cow<'_, str> {
+        use std::borrow::Cow;
+        if self.0 == 0 {
+            Cow::Borrowed("ID(0)")
+        } else {
+            // Get the contents as a byte slice. IDs can have internal NUL bytes so rb_id2name,
+            // which returns a C string is more lossy than this approach.
+            let contents = unsafe { rb_id2str(*self) };
+            if contents == Qfalse {
+                Cow::Borrowed("ID(0)")
+            } else {
+                let slice = unsafe { contents.as_rstring_byte_slice() }
+                    .expect("rb_id2str() returned truthy non-string");
+                String::from_utf8_lossy(slice)
+            }
+        }
+    }
+}
+
 /// Produce a Ruby string from a Rust string slice
 pub fn rust_str_to_ruby(str: &str) -> VALUE {
     unsafe { rb_utf8_str_new(str.as_ptr() as *const _, str.len() as i64) }
@@ -1140,7 +1180,7 @@ pub(crate) mod ids {
 
                     // Lookup and cache each ID
                     $name.store(
-                        unsafe { $crate::cruby::rb_intern2(ptr.cast(), content.len() as _) },
+                        unsafe { $crate::cruby::rb_intern2(ptr.cast(), content.len() as _) }.0,
                         std::sync::atomic::Ordering::Relaxed
                     );
                 )*
@@ -1159,14 +1199,15 @@ pub(crate) mod ids {
         name: compile
         name: eval
     }
-}
 
-/// Get an CRuby `ID` to an interned string, e.g. a particular method name.
-macro_rules! ID {
-    ($id_name:ident) => {{
-        let id = $crate::cruby::ids::$id_name.load(std::sync::atomic::Ordering::Relaxed);
-        debug_assert_ne!(0, id, "ids module should be initialized");
-        id
-    }}
+    /// Get an CRuby `ID` to an interned string, e.g. a particular method name.
+    macro_rules! ID {
+        ($id_name:ident) => {{
+            let id = $crate::cruby::ids::$id_name.load(std::sync::atomic::Ordering::Relaxed);
+            debug_assert_ne!(0, id, "ids module should be initialized");
+            ID(id)
+        }}
+    }
+    pub(crate) use ID;
 }
-pub(crate) use ID;
+pub(crate) use ids::ID;

zjit/src/cruby_bindings.inc.rs

@@ -0,0 +1,80 @@
+/*! This module contains assertions we make about runtime properties of core library methods.
+ * Some properties that influence codegen:
+ *  - Whether the method has been redefined since boot
+ *  - Whether the C method can yield to the GC
+ *  - Whether the C method makes any method calls
+ *
+ * For Ruby methods, many of these properties can be inferred through analyzing the
+ * bytecode, but for C methods we resort to annotation and validation in debug builds.
+ */
+
+use crate::cruby::*;
+use std::collections::HashMap;
+use std::ffi::c_void;
+
+pub struct Annotations {
+    cfuncs: HashMap<*mut c_void, FnProperties>,
+}
+
+/// Runtime behaviors of C functions that implement a Ruby method
+#[derive(Clone, Copy, Default)]
+pub struct FnProperties {
+    /// Whether it's possible for the function to yield to the GC
+    pub no_gc: bool,
+    /// Whether it's possible for the function to make a ruby call
+    pub leaf: bool,
+}
+
+impl Annotations {
+    /// Query about properties of a C method
+    pub fn get_cfunc_properties(&self, method: *const rb_callable_method_entry_t) -> Option<FnProperties> {
+        let fn_ptr = unsafe {
+            if VM_METHOD_TYPE_CFUNC != get_cme_def_type(method) {
+                return None;
+            }
+            get_mct_func(get_cme_def_body_cfunc(method.cast()))
+        };
+        self.cfuncs.get(&fn_ptr).copied()
+    }
+}
+
+fn annotate_c_method(props_map: &mut HashMap<*mut c_void, FnProperties>, class: VALUE, method_name: &'static str, props: FnProperties) {
+    // Lookup function pointer of the C method
+    let fn_ptr = unsafe {
+        // TODO(alan): (side quest) make rust methods and clean up glue code for rb_method_cfunc_t and
+        // rb_method_definition_t.
+        let method_id = rb_intern2(method_name.as_ptr().cast(), method_name.len() as _);
+        let method = rb_method_entry_at(class, method_id);
+        assert!(!method.is_null());
+        // ME-to-CME cast is fine due to identical layout
+        debug_assert_eq!(VM_METHOD_TYPE_CFUNC, get_cme_def_type(method.cast()));
+        get_mct_func(get_cme_def_body_cfunc(method.cast()))
+    };
+
+    props_map.insert(fn_ptr, props);
+}
+
+/// Gather annotations. Run this right after boot since the annotations
+/// are about the stock versions of methods.
+pub fn init() -> Annotations {
+    let cfuncs = &mut HashMap::new();
+
+    macro_rules! annotate {
+        ($module:ident, $method_name:literal, $($properties:ident),+) => {
+            let mut props = FnProperties::default();
+            $(
+                props.$properties = true;
+            )+
+            annotate_c_method(cfuncs, unsafe { $module }, $method_name, props);
+        }
+    }
+
+    annotate!(rb_mKernel, "itself", no_gc, leaf);
+    annotate!(rb_cString, "bytesize", no_gc, leaf);
+    annotate!(rb_cModule, "name", no_gc, leaf);
+    annotate!(rb_cModule, "===", no_gc, leaf);
+
+    Annotations {
+        cfuncs: std::mem::take(cfuncs)
+    }
+}