ZJIT: Add HIR DebugStatement insn to enable print-style debugging

Useful for printing more information while debugging
but keeping the statements interleaved with the HIR.

With a local change like this

    diff --git a/zjit/src/hir.rs b/zjit/src/hir.rs
    index bff384f..de5b41caa1 100644
    --- a/zjit/src/hir.rs
    +++ b/zjit/src/hir.rs
    @@ -2491,6 +2491,8 @@ fn type_specialize(&mut self) {
                                cme = unsafe { rb_aliased_callable_method_entry(cme) };
                                def_type = unsafe { get_cme_def_type(cme) };
                            }
    +                        eprintln!("WTH");
    +                        hir_debug_statement!(self, block, "HOWDY def_type {:?}", def_type);
                            if def_type == VM_METHOD_TYPE_ISEQ {
                                // TODO(max): Allow non-iseq; cache cme
                                // Only specialize positional-positional calls

The print statement (1) shows up early (anywhere)
whereas the HIR debug statement (2) is interleaved with the rest of
the HIR so you can easily correlate debug info to the compilation of
whatever function you are observing:

    1.  WTH                                <- shows up before all hir is dumped
        Optimized HIR:
        fn test@test.rb:2:
        bb0():
          EntryPoint interpreter
          v1:BasicObject = LoadSelf
          Jump bb2(v1)
        bb1(v4:BasicObject):
          EntryPoint JIT(0)
          Jump bb2(v4)
        bb2(v6:BasicObject):
          v11:Fixnum[1] = Const Value(1)
    2.    # HOWDY def_type 0
          PatchPoint MethodRedefined(Object@0x10184ed10, foo@0x9c01, cme:0x101967060)

The debug statements show up in HIR, LIR, and disasm:

    bb2(v6:BasicObject):
      v11:Fixnum[1] = Const Value(1)
      # HOWDY def_type 0
      PatchPoint MethodRedefined(Object@0x1220fed10, foo@0x9c01, cme:0x123717060)

--

    PatchPoint Exit(PatchPoint(NoTracePoint))
    # Insn: v11 Const Value(1)
    # Insn: v18 # HOWDY def_type 0
    # Insn: v19 PatchPoint MethodRedefined(Object@0x103aaed00, foo@0x9c01, cme:0x103bc7080)
    PatchPoint Exit(PatchPoint(MethodRedefined(Object@0x103aaed00, foo@0x9c01, cme:0x103bc7080)))

--

    0x1230bc0f0: nop
    # Insn: v11 Const Value(1)
    # Insn: v18 # HOWDY def_type 0
    # Insn: v19 PatchPoint MethodRedefined(Object@0x103c6ed20, foo@0x9c01, cme:0x103d87070)
    0x1230bc0f4: nop

Author: rwstauner

zjit/src/codegen.rs

@@ -375,6 +375,7 @@ fn gen_insn(cb: &mut CodeBlock, jit: &mut JITState, asm: &mut Assembler, functio
         Insn::ToRegexp { opt, values, state } => gen_toregexp(jit, asm, *opt, opnds!(values), &function.frame_state(*state)),
         Insn::Param => unreachable!("block.insns should not have Insn::Param"),
         Insn::Snapshot { .. } => return Ok(()), // we don't need to do anything for this instruction at the moment
+        Insn::DebugStatement { .. } => return Ok(()), // debugging instruction, no code generation needed
         Insn::Jump(branch) => no_output!(gen_jump(jit, asm, branch)),
         Insn::IfTrue { val, target } => no_output!(gen_if_true(jit, asm, opnd!(val), target)),
         Insn::IfFalse { val, target } => no_output!(gen_if_false(jit, asm, opnd!(val), target)),

zjit/src/hir.rs

@@ -20,6 +20,16 @@ use SendFallbackReason::*;
 mod tests;
 mod opt_tests;
 
+#[allow(unused_macros)]
+macro_rules! hir_debug_statement {
+    ($func:expr, $block:expr, $($arg:tt)*) => {
+        $func.push_debug_statement($block, format!($($arg)*))
+    };
+}
+
+#[allow(unused_imports)]
+pub(crate) use hir_debug_statement;
+
 /// An index of an [`Insn`] in a [`Function`]. This is a popular
 /// type since this effectively acts as a pointer to an [`Insn`].
 /// See also: [`Function::find`].
@@ -932,6 +942,9 @@ pub enum Insn {
     /// Equivalent of RUBY_VM_CHECK_INTS. Automatically inserted by the compiler before jumps and
     /// return instructions.
     CheckInterrupts { state: InsnId },
+
+    /// Debugging statement that can be inserted into HIR for diagnostics
+    DebugStatement { message: String },
 }
 
 impl Insn {
@@ -943,7 +956,8 @@ impl Insn {
             | Insn::PatchPoint { .. } | Insn::SetIvar { .. } | Insn::SetClassVar { .. } | Insn::ArrayExtend { .. }
             | Insn::ArrayPush { .. } | Insn::SideExit { .. } | Insn::SetGlobal { .. }
             | Insn::SetLocal { .. } | Insn::Throw { .. } | Insn::IncrCounter(_) | Insn::IncrCounterPtr { .. }
-            | Insn::CheckInterrupts { .. } | Insn::GuardBlockParamProxy { .. } | Insn::StoreField { .. } | Insn::WriteBarrier { .. } => false,
+            | Insn::CheckInterrupts { .. } | Insn::GuardBlockParamProxy { .. } | Insn::StoreField { .. } | Insn::WriteBarrier { .. }
+            | Insn::DebugStatement { .. } => false,
             _ => true,
         }
     }
@@ -1011,6 +1025,7 @@ impl Insn {
             Insn::BoxBool { .. } => false,
             Insn::IsBitEqual { .. } => false,
             Insn::IsA { .. } => false,
+            Insn::DebugStatement { .. } => true,
             _ => true,
         }
     }
@@ -1340,6 +1355,7 @@ impl<'a> std::fmt::Display for InsnPrinter<'a> {
             Insn::IncrCounter(counter) => write!(f, "IncrCounter {counter:?}"),
             Insn::CheckInterrupts { .. } => write!(f, "CheckInterrupts"),
             Insn::IsA { val, class } => write!(f, "IsA {val}, {class}"),
+            Insn::DebugStatement { message } => write!(f, "# {message}"),
         }
     }
 }
@@ -1692,6 +1708,10 @@ impl Function {
         id
     }
 
+    pub fn push_debug_statement(&mut self, block: BlockId, message: String) -> InsnId {
+        self.push_insn(block, Insn::DebugStatement { message })
+    }
+
     // Add an instruction to an SSA block
     fn push_insn_id(&mut self, block: BlockId, insn_id: InsnId) -> InsnId {
         self.blocks[block.0].insns.push(insn_id);
@@ -1811,7 +1831,8 @@ impl Function {
                     | LoadEC
                     | LoadSelf
                     | IncrCounterPtr {..}
-                    | IncrCounter(_)) => result.clone(),
+                    | IncrCounter(_)
+                    | DebugStatement {..}) => result.clone(),
             &Snapshot { state: FrameState { iseq, insn_idx, pc, ref stack, ref locals } } =>
                 Snapshot {
                     state: FrameState {
@@ -2023,7 +2044,7 @@ impl Function {
             | Insn::PatchPoint { .. } | Insn::SetIvar { .. } | Insn::SetClassVar { .. } | Insn::ArrayExtend { .. }
             | Insn::ArrayPush { .. } | Insn::SideExit { .. } | Insn::SetLocal { .. } | Insn::IncrCounter(_)
             | Insn::CheckInterrupts { .. } | Insn::GuardBlockParamProxy { .. } | Insn::IncrCounterPtr { .. }
-            | Insn::StoreField { .. } | Insn::WriteBarrier { .. } =>
+            | Insn::StoreField { .. } | Insn::WriteBarrier { .. } | Insn::DebugStatement { .. } =>
                 panic!("Cannot infer type of instruction with no output: {}. See Insn::has_output().", self.insns[insn.0]),
             Insn::Const { val: Const::Value(val) } => Type::from_value(*val),
             Insn::Const { val: Const::CBool(val) } => Type::from_cbool(*val),
@@ -3602,7 +3623,8 @@ impl Function {
             | &Insn::PutSpecialObject { .. }
             | &Insn::IsBlockGiven
             | &Insn::IncrCounter(_)
-            | &Insn::IncrCounterPtr { .. } =>
+            | &Insn::IncrCounterPtr { .. }
+            | &Insn::DebugStatement { .. } =>
                 {}
             &Insn::PatchPoint { state, .. }
             | &Insn::CheckInterrupts { state }
@@ -4329,7 +4351,8 @@ impl Function {
             | Insn::GetSpecialNumber { .. }
             | Insn::GetSpecialSymbol { .. }
             | Insn::GetLocal { .. }
-            | Insn::StoreField { .. } => {
+            | Insn::StoreField { .. }
+            | Insn::DebugStatement { .. } => {
                 Ok(())
             }
             // Instructions with 1 Ruby object operand