Function instrument_code

crates/vm/src/stdlib/sys/monitoring.rs:237–510

Rewrite a code object's bytecode in-place with layered instrumentation. Three layers (outermost first): 1. INSTRUMENTED_LINE — wraps line-start instructions (stores original in side-table) 2. INSTRUMENTED_INSTRUCTION — wraps all traceable instructions (stores original in side-table) 3. Regular INSTRUMENTED_* — direct 1:1 opcode swap (no side-table needed) De-instrumentation peels layers in rever

(code: &PyCode, events: u32)

///
/// De-instrumentation peels layers in reverse order.
pub fn instrument_code(code: &PyCode, events: u32) {
    use rustpython_compiler_core::bytecode::{self, Instruction};

    let len = code.code.instructions.len();
    let mut monitoring_data = code.monitoring_data.lock();

    // === Phase 1-3: De-instrument all layers (outermost first) ===

    // Phase 1: Remove INSTRUMENTED_LINE → restore from side-table
    if let Some(data) = monitoring_data.as_mut() {
        for i in 0..len {
            if data.line_opcodes[i] != 0 {
                let original = Instruction::try_from(data.line_opcodes[i])
                    .expect("invalid opcode in line side-table");
                unsafe {
                    code.code.instructions.replace_op(i, original);
                }
                data.line_opcodes[i] = 0;
            }
        }
    }

    // Phase 2: Remove INSTRUMENTED_INSTRUCTION → restore from side-table
    if let Some(data) = monitoring_data.as_mut() {
        for i in 0..len {
            if data.per_instruction_opcodes[i] != 0 {
                let original = Instruction::try_from(data.per_instruction_opcodes[i])
                    .expect("invalid opcode in instruction side-table");
                unsafe {
                    code.code.instructions.replace_op(i, original);
                }
                data.per_instruction_opcodes[i] = 0;
            }
        }
    }

    // Phase 3: Remove regular INSTRUMENTED_* and specialized opcodes → restore base opcodes.
    // Also clear all CACHE entries so specialization starts fresh.
    {
        let mut i = 0;
        while i < len {
            let op = code.code.instructions[i].op;
            let base_op = op.deoptimize();
            if u8::from(base_op) != u8::from(op) {
                unsafe {
                    code.code.instructions.replace_op(i, base_op);
                }
            }
            let caches = base_op.cache_entries();
            // Zero all CACHE entries (the op+arg bytes may have been overwritten
            // by specialization with arbitrary data like pointers).
            for c in 1..=caches {
                if i + c < len {
                    unsafe {
                        code.code.instructions.write_cache_u16(i + c, 0);
                    }
                }
            }