Insn::SetIvar { self_val, id, val, state: _ } => return gen_setivar(asm, opnd!(self_val), *id, opnd!(val)),

Insn::SideExit { state } => return gen_side_exit(jit, asm, &function.frame_state(*state)),

Insn::PutSpecialObject { value_type } => gen_putspecialobject(asm, *value_type),

_ => {

debug!("ZJIT: gen_function: unexpected insn {:?}", insn);

return None;

Some(asm.csel_ge(Qtrue.into(), Qfalse.into()))

}

/// Evaluate if a value is truthy

/// Produces a CBool type (0 or 1)

/// In Ruby, only nil and false are falsy

pub fn rb_assert_iseq_handle(handle: VALUE);

pub fn rb_IMEMO_TYPE_P(imemo: VALUE, imemo_type: imemo_type) -> ::std::os::raw::c_int;

pub fn rb_assert_cme_handle(handle: VALUE);

}

BOP_FREEZE => write!(f, "BOP_FREEZE")?,

BOP_UMINUS => write!(f, "BOP_UMINUS")?,

BOP_MAX => write!(f, "BOP_MAX")?,

_ => write!(f, "{bop}")?,

}

write!(f, ")")

// Distinct from `SendWithoutBlock` with `mid:to_s` because does not have a point for String to_s being redefined

ObjToString { val: InsnId, call_info: CallInfo, cd: *const rb_call_data, state: InsnId },

/// Side-exit if val doesn't have the expected type.

GuardType { val: InsnId, guard_type: Type, state: InsnId },

Insn::ArrayExtend { left, right, .. } => write!(f, "ArrayExtend {left}, {right}"),

Insn::ArrayPush { array, val, .. } => write!(f, "ArrayPush {array}, {val}"),

Insn::ObjToString { val, .. } => { write!(f, "ObjToString {val}") },

Insn::SideExit { .. } => write!(f, "SideExit"),

Insn::PutSpecialObject { value_type } => {

write!(f, "PutSpecialObject {}", value_type)

cd: *cd,

state: *state,

},

SendWithoutBlock { self_val, call_info, cd, args, state } => SendWithoutBlock {

self_val: find!(*self_val),

call_info: call_info.clone(),

Insn::ToNewArray { .. } => types::ArrayExact,

Insn::ToArray { .. } => types::ArrayExact,

Insn::ObjToString { .. } => types::BasicObject,

}

}

}

}

/// Rewrite SendWithoutBlock opcodes into SendWithoutBlockDirect opcodes if we know the target

/// ISEQ statically. This removes run-time method lookups and opens the door for inlining.

fn optimize_direct_sends(&mut self) {

self.try_rewrite_freeze(block, insn_id, self_val),

Insn::SendWithoutBlock { self_val, call_info: CallInfo { method_name }, args, .. } if method_name == "-@" && args.len() == 0 =>

self.try_rewrite_uminus(block, insn_id, self_val),

Insn::SendWithoutBlock { mut self_val, call_info, cd, args, state } => {

let frame_state = self.frame_state(state);

let (klass, guard_equal_to) = if let Some(klass) = self.type_of(self_val).runtime_exact_ruby_class() {

self.make_equal_to(insn_id, replacement);

}

Insn::ObjToString { val, call_info, cd, state, .. } => {

// behaves differently from `SendWithoutBlock` with `mid:to_s` because ObjToString should not have a point for String to_s being redefined

self.make_equal_to(insn_id, val);

} else {

self.make_equal_to(insn_id, replacement)

}

}

_ => { self.push_insn_id(block, insn_id); }

}

}

worklist.push_back(val);

worklist.push_back(state);

}

Insn::GetGlobal { state, .. } |

Insn::SideExit { state } => worklist.push_back(state),

}

YARVINSN_putobject => { state.stack_push(fun.push_insn(block, Insn::Const { val: Const::Value(get_arg(pc, 0)) })); },

YARVINSN_putspecialobject => {

let value_type = SpecialObjectType::from(get_arg(pc, 0).as_u32());

}

YARVINSN_putstring => {

let val = fun.push_insn(block, Insn::Const { val: Const::Value(get_arg(pc, 0)) });

let objtostring = fun.push_insn(block, Insn::ObjToString { val: recv, call_info: CallInfo { method_name }, cd, state: exit_id });

state.stack_push(objtostring)

}

_ => {

// Unknown opcode; side-exit into the interpreter

let exit_id = fun.push_insn(block, Insn::Snapshot { state: exit_state });

assert_method_hir("test", expect![[r#"

fn test:

bb0(v0:BasicObject, v1:BasicObject):

v5:HashExact = NewHash

v7:BasicObject = SendWithoutBlock v3, :core#hash_merge_kwd, v5, v1

v10:Fixnum[1] = Const Value(1)

v12:BasicObject = SendWithoutBlock v8, :core#hash_merge_ptr, v7, v9, v10

SideExit

assert_method_hir_with_opcode("test", YARVINSN_putspecialobject, expect![[r#"

fn test:

bb0(v0:BasicObject):

v3:BasicObject = PutSpecialObject CBase

v7:BasicObject = SendWithoutBlock v2, :core#set_method_alias, v3, v4, v5

Return v7

"#]]);

}

#[test]

eval("

def test = \"#{1}\"

");

v2:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))

v3:Fixnum[1] = Const Value(1)

v5:BasicObject = ObjToString v3

SideExit

"#]]);

}

}

#[test]

eval(r##"

def test = "#{('foo')}"

"##);

}

#[test]

eval(r##"

def test = "#{1}"

"##);

bb0(v0:BasicObject):

v2:StringExact[VALUE(0x1000)] = Const Value(VALUE(0x1000))

v3:Fixnum[1] = Const Value(1)

SideExit

"#]]);

}

}

use crate::cruby::{rb_cInteger, rb_cFloat, rb_cArray, rb_cHash, rb_cString, rb_cSymbol, rb_cObject, rb_cTrueClass, rb_cFalseClass, rb_cNilClass, rb_cRange};

use crate::cruby::ClassRelationship;

use crate::cruby::get_class_name;

use crate::hir::PtrPrintMap;

#[derive(Copy, Clone, Debug, PartialEq)]

let ty = printer.inner;

match ty.spec {

Specialization::Any | Specialization::Empty => { Ok(()) },

Specialization::Object(val) => write!(f, "[{}]", val.print(printer.ptr_map)),

Specialization::Type(val) => write!(f, "[class:{}]", get_class_name(val)),

Specialization::TypeExact(val) => write!(f, "[class_exact:{}]", get_class_name(val)),