ar_start: i32,

ar_end: i32,

ar_line: i32,

computed_line: i32,

reader: LineTableReader<'a>,

fn new(linetable: &'a [u8], first_line: i32) -> Self {

PyCodeAddressRange {

ar_start: 0,

ar_end: 0,

ar_line: -1,

computed_line: first_line,

reader: LineTableReader::new(linetable),

}

}

/// Check if this is a NO_LINE marker (code 15)

fn is_no_line_marker(byte: u8) -> bool {

(byte >> 3) == 0x1f

}

/// Advance to next address range

fn advance(&mut self) -> bool {

if self.reader.at_end() {

return false;

}

let first_byte = match self.reader.read_byte() {

Some(b) => b,

None => return false,

};

if (first_byte & 0x80) == 0 {

return false; // Invalid linetable

}

let code = (first_byte >> 3) & 0x0f;

let length = ((first_byte & 0x07) + 1) as i32;

// Get line delta for this entry

let line_delta = self.get_line_delta(code);

// Update computed line

self.computed_line += line_delta;

// Check for NO_LINE marker

if Self::is_no_line_marker(first_byte) {

self.ar_line = -1;

} else {

self.ar_line = self.computed_line;

}

// Update address range

self.ar_start = self.ar_end;

self.ar_end += length * 2; // sizeof(_Py_CODEUNIT) = 2

// Skip remaining bytes for this entry

while !self.reader.at_end() {

if let Some(b) = self.reader.peek_byte() {

if (b & 0x80) != 0 {

break;

}

self.reader.read_byte();

} else {

break;

}

}

true

}

fn get_line_delta(&mut self, code: u8) -> i32 {

let kind = match PyCodeLocationInfoKind::from_code(code) {

Some(k) => k,

None => return 0,

};

match kind {

PyCodeLocationInfoKind::None => 0, // NO_LINE marker

PyCodeLocationInfoKind::Long => {

let delta = self.reader.read_signed_varint();

// Skip end_line, col, end_col

self.reader.read_varint();

self.reader.read_varint();

self.reader.read_varint();

delta

}

PyCodeLocationInfoKind::NoColumns => self.reader.read_signed_varint(),

PyCodeLocationInfoKind::OneLine0 => {

self.reader.read_byte(); // Skip column

self.reader.read_byte(); // Skip end column

0

}

PyCodeLocationInfoKind::OneLine1 => {

self.reader.read_byte(); // Skip column

self.reader.read_byte(); // Skip end column

1

}

PyCodeLocationInfoKind::OneLine2 => {

self.reader.read_byte(); // Skip column

self.reader.read_byte(); // Skip end column

2

}

_ if kind.is_short() => {

self.reader.read_byte(); // Skip column byte

0

}

_ => 0,

}

}

#[pyarg(named, optional)]

co_posonlyargcount: OptionalArg<u32>,

#[pyarg(named, optional)]

co_argcount: OptionalArg<u32>,

#[pyarg(named, optional)]

co_kwonlyargcount: OptionalArg<u32>,

#[pyarg(named, optional)]

co_filename: OptionalArg<PyStrRef>,

#[pyarg(named, optional)]

co_firstlineno: OptionalArg<u32>,

#[pyarg(named, optional)]

co_consts: OptionalArg<Vec<PyObjectRef>>,

#[pyarg(named, optional)]

co_name: OptionalArg<PyStrRef>,

#[pyarg(named, optional)]

co_names: OptionalArg<Vec<PyObjectRef>>,

#[pyarg(named, optional)]

co_flags: OptionalArg<u32>,

#[pyarg(named, optional)]

co_varnames: OptionalArg<Vec<PyObjectRef>>,

#[pyarg(named, optional)]

co_nlocals: OptionalArg<u32>,

#[pyarg(named, optional)]

co_stacksize: OptionalArg<u32>,

#[pyarg(named, optional)]

co_code: OptionalArg<crate::builtins::PyBytesRef>,

#[pyarg(named, optional)]

co_linetable: OptionalArg<crate::builtins::PyBytesRef>,

#[pyarg(named, optional)]

co_exceptiontable: OptionalArg<crate::builtins::PyBytesRef>,

#[pyarg(named, optional)]

co_freevars: OptionalArg<Vec<PyObjectRef>>,

#[pyarg(named, optional)]

co_cellvars: OptionalArg<Vec<PyObjectRef>>,

#[pyarg(named, optional)]

co_qualname: OptionalArg<PyStrRef>,

fn borrow(&self) -> &PyObject {

&self.0

}

fn from(obj: Literal) -> Self {

obj.0

}

fn from(obj: PyObjectRef) -> Self {

Self(obj)

}

match_class!(match obj {

ref i @ super::int::PyInt => {

let value = i.as_bigint();

if obj.class().is(super::bool_::PyBool::static_type()) {

BorrowedConstant::Boolean {

value: !value.is_zero(),

}

} else {

BorrowedConstant::Integer { value }

}

}

ref f @ super::float::PyFloat => BorrowedConstant::Float { value: f.to_f64() },

ref c @ super::complex::PyComplex => BorrowedConstant::Complex {

value: c.to_complex()

},

ref s @ super::pystr::PyStr => BorrowedConstant::Str { value: s.as_wtf8() },

ref b @ super::bytes::PyBytes => BorrowedConstant::Bytes {

value: b.as_bytes()

},

ref c @ PyCode => {

BorrowedConstant::Code { code: &c.code }

}

ref t @ super::tuple::PyTuple => {

let elements = t.as_slice();

// SAFETY: Literal is repr(transparent) over PyObjectRef, and a Literal tuple only ever

// has other literals as elements

let elements = unsafe { &*(elements as *const [PyObjectRef] as *const [Literal]) };

BorrowedConstant::Tuple { elements }

}

super::singletons::PyNone => BorrowedConstant::None,

super::slice::PyEllipsis => BorrowedConstant::Ellipsis,

ref s @ super::slice::PySlice => {

// Constant pool slices always store Some() for start/step (even for None).

// Box::leak the array so it outlives the borrow. Leak is acceptable since

// constant pool objects live for the program's lifetime.

let start = s.start.clone().unwrap();

let stop = s.stop.clone();

let step = s.step.clone().unwrap();

let arr = Box::leak(Box::new([Literal(start), Literal(stop), Literal(step)]));

BorrowedConstant::Slice { elements: arr }

}

ref fs @ super::set::PyFrozenSet => {

// Box::leak the elements so they outlive the borrow. Leak is acceptable since

// constant pool objects live for the program's lifetime.

let elems: Vec<Literal> = fs.elements().into_iter().map(Literal).collect();

let elements = Box::leak(elems.into_boxed_slice());

BorrowedConstant::Frozenset { elements }

}

_ => panic!("unexpected payload for constant python value"),

})

type Name = &'static PyStrInterned;

fn borrow_constant(&self) -> BorrowedConstant<'_, Self> {

borrow_obj_constant(&self.0)

}

type Constant = Literal;

fn make_constant<C: Constant>(&self, constant: BorrowedConstant<'_, C>) -> Self::Constant {

let ctx = self.0;

let obj = match constant {

BorrowedConstant::Integer { value } => ctx.new_bigint(value).into(),

BorrowedConstant::Float { value } => ctx.new_float(value).into(),

BorrowedConstant::Complex { value } => ctx.new_complex(value).into(),

BorrowedConstant::Str { value } if value.len() <= 20 => {

ctx.intern_str(value).to_object()

}

BorrowedConstant::Str { value } => ctx.new_str(value).into(),

BorrowedConstant::Bytes { value } => ctx.new_bytes(value.to_vec()).into(),

BorrowedConstant::Boolean { value } => ctx.new_bool(value).into(),

BorrowedConstant::Code { code } => ctx.new_code(code.map_clone_bag(self)).into(),

BorrowedConstant::Tuple { elements } => {

let elements = elements

.iter()

.map(|constant| self.make_constant(constant.borrow_constant()).0)

.collect();

ctx.new_tuple(elements).into()

}

BorrowedConstant::Slice { elements } => {

let [start, stop, step] = elements;

let start_obj = self.make_constant(start.borrow_constant()).0;

let stop_obj = self.make_constant(stop.borrow_constant()).0;

let step_obj = self.make_constant(step.borrow_constant()).0;

// Store as PySlice with Some() for all fields (even None values)

// so borrow_obj_constant can reference them.

use crate::builtins::PySlice;

PySlice {

start: Some(start_obj),

stop: stop_obj,

step: Some(step_obj),

}

.into_ref(ctx)

.into()

}

BorrowedConstant::Frozenset { elements: _ } => {

// Creating a frozenset requires VirtualMachine for element hashing.

// PyObjBag only has Context, so we cannot construct PyFrozenSet here.

// Frozenset constants from .pyc are handled by PyMarshalBag which has VM access.

unimplemented!(

"frozenset constant in PyObjBag::make_constant requires VirtualMachine"

)

}

BorrowedConstant::None => ctx.none(),

BorrowedConstant::Ellipsis => ctx.ellipsis.clone().into(),

};

Literal(obj)

}

fn make_name(&self, name: &str) -> &'static PyStrInterned {

self.0.intern_str(name)

}

fn make_int(&self, value: BigInt) -> Self::Constant {

Literal(self.0.new_int(value).into())

}

fn make_tuple(&self, elements: impl Iterator<Item = Self::Constant>) -> Self::Constant {

Literal(self.0.new_tuple(elements.map(|lit| lit.0).collect()).into())

}

fn make_code(&self, code: CodeObject) -> Self::Constant {

Literal(self.0.new_code(code).into())

}

type Constant = Literal;

fn make_constant<C: Constant>(&self, constant: BorrowedConstant<'_, C>) -> Self::Constant {

let vm = self.0;

let ctx = &vm.ctx;

let obj = match constant {

BorrowedConstant::Integer { value } => ctx.new_bigint(value).into(),

BorrowedConstant::Float { value } => ctx.new_float(value).into(),

BorrowedConstant::Complex { value } => ctx.new_complex(value).into(),

BorrowedConstant::Str { value } if value.len() <= 20 => {

ctx.intern_str(value).to_object()

}

BorrowedConstant::Str { value } => ctx.new_str(value).into(),

BorrowedConstant::Bytes { value } => ctx.new_bytes(value.to_vec()).into(),

BorrowedConstant::Boolean { value } => ctx.new_bool(value).into(),

BorrowedConstant::Code { code } => {

PyCode::new_ref_with_bag(vm, code.map_clone_bag(self)).into()

}

BorrowedConstant::Tuple { elements } => {

let elements = elements

.iter()

.map(|constant| self.make_constant(constant.borrow_constant()).0)

.collect();

ctx.new_tuple(elements).into()

}

BorrowedConstant::Slice { elements } => {

let [start, stop, step] = elements;

let start_obj = self.make_constant(start.borrow_constant()).0;

let stop_obj = self.make_constant(stop.borrow_constant()).0;

let step_obj = self.make_constant(step.borrow_constant()).0;

use crate::builtins::PySlice;

PySlice {

start: Some(start_obj),

stop: stop_obj,

step: Some(step_obj),

}

.into_ref(ctx)

.into()

}

BorrowedConstant::Frozenset { elements } => {

let elements = elements

.iter()

.map(|constant| self.make_constant(constant.borrow_constant()).0);

PyFrozenSet::from_iter(vm, elements)

.unwrap()

.into_ref(ctx)

.into()

}

BorrowedConstant::None => ctx.none(),

BorrowedConstant::Ellipsis => ctx.ellipsis.clone().into(),

};

Literal(obj)

}

fn make_name(&self, name: &str) -> &'static PyStrInterned {

self.0.ctx.intern_str(name)

}

fn make_int(&self, value: BigInt) -> Self::Constant {

Literal(self.0.ctx.new_int(value).into())

}

fn make_tuple(&self, elements: impl Iterator<Item = Self::Constant>) -> Self::Constant {

Literal(

self.0

.ctx

.new_tuple(elements.map(|lit| lit.0).collect())

.into(),

)

}

fn make_code(&self, code: CodeObject) -> Self::Constant {

Literal(PyCode::new_ref_with_bag(self.0, code).into())

}

fn into_code_object(self, _ctx: &Context) -> Self {

self

}

/// Original opcodes at positions with INSTRUMENTED_LINE.

/// Indexed by instruction index. 0 = not instrumented for LINE.

pub line_opcodes: Vec<u8>,

/// Original opcodes at positions with INSTRUMENTED_INSTRUCTION.

/// Indexed by instruction index. 0 = not instrumented for INSTRUCTION.

pub per_instruction_opcodes: Vec<u8>,

pub code: CodeObject,

source_path: AtomicPtr<PyStrInterned>,

/// Version counter for lazy re-instrumentation.

/// Compared against `PyGlobalState::instrumentation_version` at RESUME.

pub instrumentation_version: AtomicU64,

/// Side-table for INSTRUMENTED_LINE / INSTRUMENTED_INSTRUCTION.

pub monitoring_data: PyMutex<Option<CoMonitoringData>>,

/// Whether adaptive counters have been initialized (lazy quickening).

pub quickened: core::sync::atomic::AtomicBool,

type Target = CodeObject;

fn deref(&self) -> &Self::Target {

&self.code

}

pub fn new(code: CodeObject) -> Self {

let sp = code.source_path as *const PyStrInterned as *mut PyStrInterned;

Self {

code,

source_path: AtomicPtr::new(sp),

instrumentation_version: AtomicU64::new(0),

monitoring_data: PyMutex::new(None),

quickened: core::sync::atomic::AtomicBool::new(false),

}

}

pub fn source_path(&self) -> &'static PyStrInterned {

// SAFETY: always points to a valid &'static PyStrInterned (interned strings are never deallocated)

unsafe { &*self.source_path.load(Ordering::Relaxed) }

}

pub fn set_source_path(&self, new: &'static PyStrInterned) {

self.source_path.store(

new as *const PyStrInterned as *mut PyStrInterned,

Ordering::Relaxed,

);

}

pub fn new_ref_with_bag(vm: &VirtualMachine, code: CodeObject) -> PyRef<Self> {

PyRef::new_ref(Self::new(code), vm.ctx.types.code_type.to_owned(), None)

}

pub fn new_ref_from_bytecode(vm: &VirtualMachine, code: bytecode::CodeObject) -> PyRef<Self> {

Self::new_ref_with_bag(vm, code.map_bag(PyVmBag(vm)))

}

pub fn new_ref_from_frozen<B: AsRef<[u8]>>(

vm: &VirtualMachine,

code: frozen::FrozenCodeObject<B>,

) -> PyRef<Self> {

Self::new_ref_with_bag(vm, code.decode(PyVmBag(vm)))

}

#[cfg(feature = "host_env")]

pub fn from_pyc_path(path: &std::path::Path, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {

let name = match path.file_stem() {

Some(stem) => stem.display().to_string(),

None => "".to_owned(),

};

let content = crate::host_env::fs::read(path).map_err(|e| e.to_pyexception(vm))?;

Self::from_pyc(

&content,

Some(&name),

Some(&path.display().to_string()),

Some("<source>"),

vm,

)

}

#[cfg(not(feature = "host_env"))]

pub fn from_pyc_path(_path: &std::path::Path, vm: &VirtualMachine) -> PyResult<PyRef<Self>> {

Err(vm.new_runtime_error("loading a pyc file requires the `host_env` feature"))

}

pub fn from_pyc(

pyc_bytes: &[u8],

name: Option<&str>,

bytecode_path: Option<&str>,

source_path: Option<&str>,

vm: &VirtualMachine,

) -> PyResult<PyRef<Self>> {

if !crate::import::check_pyc_magic_number_bytes(pyc_bytes) {

return Err(vm.new_value_error("pyc bytes has wrong MAGIC"));

}

let bootstrap_external = vm.import("_frozen_importlib_external", 0)?;

let compile_bytecode = bootstrap_external.get_attr("_compile_bytecode", vm)?;

// 16 is the pyc header length

let Some((_, code_bytes)) = pyc_bytes.split_at_checked(16) else {

return Err(vm.new_value_error(format!(

"pyc_bytes header is broken. 16 bytes expected but {} bytes given.",

pyc_bytes.len()

)));

};

let code_bytes_obj = vm.ctx.new_bytes(code_bytes.to_vec());

let compiled =

compile_bytecode.call((code_bytes_obj, name, bytecode_path, source_path), vm)?;

compiled.try_downcast(vm)

}

fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

write!(f, "code: {:?}", self.code)

}

#[inline]

fn class(ctx: &Context) -> &'static Py<PyType> {

ctx.types.code_type

}

#[inline]

fn repr_str(zelf: &Py<Self>, _vm: &VirtualMachine) -> PyResult<String> {

let code = &zelf.code;

Ok(format!(

"<code object {} at {:#x} file {:?}, line {}>",

code.obj_name,

zelf.get_id(),

zelf.source_path().as_str(),

code.first_line_number.map_or(-1, |n| n.get() as i32)

))

}

fn cmp(

zelf: &Py<Self>,

other: &PyObject,

op: crate::types::PyComparisonOp,

vm: &VirtualMachine,

) -> PyResult<crate::function::PyComparisonValue> {

op.eq_only(|| {

let other = class_or_notimplemented!(Self, other);

let a = &zelf.code;

let b = &other.code;

let eq = a.obj_name == b.obj_name

&& a.arg_count == b.arg_count

&& a.posonlyarg_count == b.posonlyarg_count

&& a.kwonlyarg_count == b.kwonlyarg_count

&& a.flags == b.flags

&& a.first_line_number == b.first_line_number

&& a.instructions.original_bytes() == b.instructions.original_bytes()

&& a.linetable == b.linetable

&& a.exceptiontable == b.exceptiontable

&& a.names == b.names

&& a.varnames == b.varnames

&& a.freevars == b.freevars

&& a.cellvars == b.cellvars

&& {

let a_consts: Vec<_> = a.constants.iter().map(|c| c.0.clone()).collect();

let b_consts: Vec<_> = b.constants.iter().map(|c| c.0.clone()).collect();

if a_consts.len() != b_consts.len() {

false

} else {

let mut eq = true;

for (ac, bc) in a_consts.iter().zip(b_consts.iter()) {

if !vm.bool_eq(ac, bc)? {

eq = false;

break;

}

}

eq

}

};

Ok(eq.into())

})

}

fn hash(zelf: &Py<Self>, vm: &VirtualMachine) -> PyResult<crate::common::hash::PyHash> {

let code = &zelf.code;

// Hash a tuple of key attributes, matching CPython's code_hash

let tuple = vm.ctx.new_tuple(vec![

vm.ctx.new_str(code.obj_name.as_str()).into(),

vm.ctx.new_int(code.arg_count).into(),

vm.ctx.new_int(code.posonlyarg_count).into(),

vm.ctx.new_int(code.kwonlyarg_count).into(),

vm.ctx.new_int(code.varnames.len()).into(),

vm.ctx.new_int(code.flags.bits()).into(),

vm.ctx

.new_int(code.first_line_number.map_or(0, |n| n.get()) as i64)

.into(),

vm.ctx.new_bytes(code.instructions.original_bytes()).into(),

{

let consts: Vec<_> = code.constants.iter().map(|c| c.0.clone()).collect();

vm.ctx.new_tuple(consts).into()

},

]);

tuple.as_object().hash(vm)

}

argcount: u32,

posonlyargcount: u32,

kwonlyargcount: u32,

nlocals: u32,

stacksize: u32,

flags: u32,

co_code: PyBytesRef,

consts: PyTupleRef,

names: PyTupleRef,

varnames: PyTupleRef,

filename: PyStrRef,

name: PyStrRef,

qualname: PyStrRef,

firstlineno: i32,

linetable: PyBytesRef,

exceptiontable: PyBytesRef,

freevars: PyTupleRef,

cellvars: PyTupleRef,

type Args = PyCodeNewArgs;

fn py_new(_cls: &Py<PyType>, args: Self::Args, vm: &VirtualMachine) -> PyResult<Self> {

// Convert names tuple to vector of interned strings

let names: Box<[&'static PyStrInterned]> = args

.names

.iter()

.map(|obj| {

let s = obj

.downcast_ref::<super::pystr::PyStr>()

.ok_or_else(|| vm.new_type_error("names must be tuple of strings"))?;

Ok(vm.ctx.intern_str(s.as_wtf8()))

})

.collect::<PyResult<Vec<_>>>()?

.into_boxed_slice();

let varnames: Box<[&'static PyStrInterned]> = args

.varnames

.iter()

.map(|obj| {

let s = obj

.downcast_ref::<super::pystr::PyStr>()

.ok_or_else(|| vm.new_type_error("varnames must be tuple of strings"))?;

Ok(vm.ctx.intern_str(s.as_wtf8()))

})

.collect::<PyResult<Vec<_>>>()?

.into_boxed_slice();

let cellvars: Box<[&'static PyStrInterned]> = args

.cellvars

.iter()

.map(|obj| {

let s = obj

.downcast_ref::<super::pystr::PyStr>()

.ok_or_else(|| vm.new_type_error("cellvars must be tuple of strings"))?;

Ok(vm.ctx.intern_str(s.as_wtf8()))

})

.collect::<PyResult<Vec<_>>>()?

.into_boxed_slice();

let freevars: Box<[&'static PyStrInterned]> = args

.freevars

.iter()

.map(|obj| {

let s = obj

.downcast_ref::<super::pystr::PyStr>()

.ok_or_else(|| vm.new_type_error("freevars must be tuple of strings"))?;

Ok(vm.ctx.intern_str(s.as_wtf8()))

})

.collect::<PyResult<Vec<_>>>()?

.into_boxed_slice();

// Check nlocals matches varnames length

if args.nlocals as usize != varnames.len() {

return Err(vm.new_value_error(format!(

"nlocals ({}) != len(varnames) ({})",

args.nlocals,

varnames.len()

)));

}

// Parse and validate bytecode from bytes

let bytecode_bytes = args.co_code.as_bytes();

let instructions = CodeUnits::try_from(bytecode_bytes)

.map_err(|e| vm.new_value_error(format!("invalid bytecode: {e}")))?;

// Convert constants

let constants = args

.consts

.iter()

.map(|obj| {

// Convert PyObject to Literal constant. For now, just wrap it

Literal(obj.clone())

})

.collect();

// Create locations (start and end pairs)

let row = if args.firstlineno > 0 {

OneIndexed::new(args.firstlineno as usize).unwrap_or(OneIndexed::MIN)

} else {

OneIndexed::MIN

};

let loc = rustpython_compiler_core::SourceLocation {