}

Instruction::ForIter { .. } => {

// Relative forward jump: target = lasti + caches + delta

self.adaptive(|s, ii, cb| s.specialize_for_iter(vm, u32::from(arg), ii, cb));

self.execute_for_iter(vm, target)?;

Ok(None)

Instruction::Send { .. } => {

// (receiver, v -- receiver, retval)

self.adaptive(|s, ii, cb| s.specialize_send(vm, ii, cb));

let receiver = self.nth_value(1);

let can_fast_send = !self.specialization_eval_frame_active(vm)

&& (receiver.downcast_ref_if_exact::<PyGenerator>(vm).is_some()

}

}

Instruction::SendGen => {

// Stack: [receiver, val] — peek receiver before popping

let receiver = self.nth_value(1);

let can_fast_send = !self.specialization_eval_frame_active(vm)

}

// Specialized LOAD_ATTR opcodes

Instruction::LoadAttrMethodNoDict => {

let cache_base = self.lasti() as usize;

let owner = self.top_value();

}

}

Instruction::LoadAttrMethodLazyDict => {

let cache_base = self.lasti() as usize;

let owner = self.top_value();

}

}

Instruction::LoadAttrMethodWithValues => {

let cache_base = self.lasti() as usize;

let attr_name = self.code.names[oparg.name_idx() as usize];

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrInstanceValue => {

let cache_base = self.lasti() as usize;

let attr_name = self.code.names[oparg.name_idx() as usize];

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrWithHint => {

let cache_base = self.lasti() as usize;

let attr_name = self.code.names[oparg.name_idx() as usize];

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrModule => {

let cache_base = self.lasti() as usize;

let attr_name = self.code.names[oparg.name_idx() as usize];

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrNondescriptorNoDict => {

let cache_base = self.lasti() as usize;

let owner = self.top_value();

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrNondescriptorWithValues => {

let cache_base = self.lasti() as usize;

let attr_name = self.code.names[oparg.name_idx() as usize];

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrClass => {

let cache_base = self.lasti() as usize;

let owner = self.top_value();

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrClassWithMetaclassCheck => {

let cache_base = self.lasti() as usize;

let owner = self.top_value();

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrGetattributeOverridden => {

let cache_base = self.lasti() as usize;

let owner = self.top_value();

let type_version = self.code.instructions.read_cache_u32(cache_base + 1);

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrSlot => {

let cache_base = self.lasti() as usize;

let owner = self.top_value();

self.load_attr_slow(vm, oparg)

}

Instruction::LoadAttrProperty => {

let cache_base = self.lasti() as usize;

let owner = self.top_value();

return Ok(None);

}

}

self.load_super_attr(vm, oparg)

}

Instruction::LoadSuperAttrMethod => {

return Ok(None);

}

}

self.load_super_attr(vm, oparg)

}

Instruction::CompareOpInt => {

self.unpack_sequence(size as u32, vm)

}

Instruction::ForIterRange => {

let iter = self.top_value();

if let Some(range_iter) = iter.downcast_ref_if_exact::<PyRangeIterator>(vm) {

if let Some(value) = range_iter.fast_next() {

}

}

Instruction::ForIterList => {

let iter = self.top_value();

if let Some(list_iter) = iter.downcast_ref_if_exact::<PyListIterator>(vm) {

if let Some(value) = list_iter.fast_next() {

}

}

Instruction::ForIterTuple => {

let iter = self.top_value();

if let Some(tuple_iter) = iter.downcast_ref_if_exact::<PyTupleIterator>(vm) {

if let Some(value) = tuple_iter.fast_next() {

}

}

Instruction::ForIterGen => {

let iter = self.top_value();

if self.specialization_eval_frame_active(vm) {

self.execute_for_iter(vm, target)?;

Instruction::InstrumentedJumpForward => {

let src_offset = (self.lasti() - 1) * 2;

let target_idx = self.lasti() + u32::from(arg);

self.jump(target);

if self.monitoring_mask & monitoring::EVENT_JUMP != 0 {

monitoring::fire_jump(vm, self.code, src_offset, target.as_u32() * 2)?;

Instruction::InstrumentedJumpBackward => {

let src_offset = (self.lasti() - 1) * 2;

let target_idx = self.lasti() + 1 - u32::from(arg);

self.jump(target);

if self.monitoring_mask & monitoring::EVENT_JUMP != 0 {

monitoring::fire_jump(vm, self.code, src_offset, target.as_u32() * 2)?;

}

Instruction::InstrumentedForIter => {

let src_offset = (self.lasti() - 1) * 2;

let continued = self.execute_for_iter(vm, target)?;

if continued {

if self.monitoring_mask & monitoring::EVENT_BRANCH_LEFT != 0 {

let obj = self.pop_value();

let value = obj.try_to_bool(vm)?;

if value {

if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {

monitoring::fire_branch_right(vm, self.code, src_offset, target_idx * 2)?;

}

let obj = self.pop_value();

let value = obj.try_to_bool(vm)?;

if !value {

if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {

monitoring::fire_branch_right(vm, self.code, src_offset, target_idx * 2)?;

}

let target_idx = self.lasti() + 1 + u32::from(arg);

let value = self.pop_value();

if vm.is_none(&value) {

if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {

monitoring::fire_branch_right(vm, self.code, src_offset, target_idx * 2)?;

}

let target_idx = self.lasti() + 1 + u32::from(arg);

let value = self.pop_value();

if !vm.is_none(&value) {

if self.monitoring_mask & monitoring::EVENT_BRANCH_RIGHT != 0 {

monitoring::fire_branch_right(vm, self.code, src_offset, target_idx * 2)?;

}

self.push_value(exception.into());

// 4. Jump to handler

Ok(None)

} else {

bytecode::Instruction::EndFor | bytecode::Instruction::InstrumentedEndFor

)

{

}

target

}

unit.op,

bytecode::Instruction::EndFor | bytecode::Instruction::InstrumentedEndFor

) {

} else {

target

}