FazBrowse GitHub Viewer | Trending |
URL:
| Home
Tools: [Download Repo ZIP]   [Original HTTPS Page]

VM and bytecode support for compiler parity · RustPython/RustPython@702b388 · GitHub

/ RustPython Public

Commit 702b388

Browse files
youknowone
committed
VM and bytecode support for compiler parity
- bytecode.rs: ConvertValue, FormatSimple, LoadFastAndClear, MakeCell instructions - frame.rs: StopIteration handling, RESUME depth support - _symtable.rs: filter inlined comprehension children - jit/instructions.rs: StoreFastLoadFast support - monitoring.rs: LINE event for non-function scopes - Remove expectedFailure markers for passing tests
1 parent 7c64b96 commit 702b388

9 files changed

Lines changed: 148 additions & 47 deletions

File tree

‎Lib/test/test_contextlib.py‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -99,8 +99,6 @@ def woohoo():
9999
raise ZeroDivisionError()
100100
self.assertEqual(state, [1, 42, 999])
101101

102-
# TODO: RUSTPYTHON
103-
@unittest.expectedFailure
104102
def test_contextmanager_traceback(self):
105103
@contextmanager
106104
def f():

‎Lib/test/test_contextlib_async.py‎

Lines changed: 0 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -252,7 +252,6 @@ async def woohoo():
252252
raise ZeroDivisionError(999)
253253
self.assertEqual(state, [1, 42, 999])
254254

255-
@unittest.expectedFailure # TODO: RUSTPYTHON
256255
async def test_contextmanager_except_stopiter(self):
257256
@asynccontextmanager
258257
async def woohoo():

‎Lib/test/test_peepholer.py‎

Lines changed: 0 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -132,7 +132,6 @@ def f():
132132
self.assertInBytecode(f, 'LOAD_CONST', None)
133133
self.check_lnotab(f)
134134

135-
@unittest.expectedFailure # TODO: RUSTPYTHON; RETURN_VALUE
136135
def test_while_one(self):
137136
# Skip over: LOAD_CONST trueconst POP_JUMP_IF_FALSE xx
138137
def f():
@@ -545,7 +544,6 @@ def f(cond, true_value, false_value):
545544
self.assertEqual(len(returns), 2)
546545
self.check_lnotab(f)
547546

548-
@unittest.expectedFailure # TODO: RUSTPYTHON; absolute jump encoding
549547
def test_elim_jump_to_uncond_jump(self):
550548
# POP_JUMP_IF_FALSE to JUMP_FORWARD --> POP_JUMP_IF_FALSE to non-jump
551549
def f():

‎crates/codegen/src/ir.rs‎

Lines changed: 23 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -209,22 +209,21 @@ impl CodeInfo {
209209
// Peephole optimizer creates superinstructions matching CPython
210210
self.peephole_optimize();
211211

212-
// insert_superinstructions (flowgraph.c): must run BEFORE optimize_load_fast
213-
self.combine_store_fast_load_fast();
214-
215-
// optimize_load_fast (flowgraph.c): LOAD_FAST → LOAD_FAST_BORROW
216-
self.optimize_load_fast_borrow();
217-
218-
// Post-codegen CFG analysis passes (flowgraph.c pipeline)
212+
// Phase 1: _PyCfg_OptimizeCodeUnit (flowgraph.c)
219213
mark_except_handlers(&mut self.blocks);
220214
label_exception_targets(&mut self.blocks);
215+
// TODO: insert_superinstructions disabled pending StoreFastLoadFast VM fix
221216
push_cold_blocks_to_end(&mut self.blocks);
217+
218+
// Phase 2: _PyCfg_OptimizedCfgToInstructionSequence (flowgraph.c)
222219
normalize_jumps(&mut self.blocks);
223220
self.dce(); // re-run within-block DCE after normalize_jumps creates new instructions
224221
self.eliminate_unreachable_blocks();
225222
duplicate_end_returns(&mut self.blocks);
226223
self.dce(); // truncate after terminal in blocks that got return duplicated
227224
self.eliminate_unreachable_blocks(); // remove now-unreachable last block
225+
// optimize_load_fast: after normalize_jumps
226+
self.optimize_load_fast_borrow();
228227
self.optimize_load_global_push_null();
229228

230229
let max_stackdepth = self.max_stackdepth()?;
@@ -850,17 +849,12 @@ impl CodeInfo {
850849
l / r
851850
}
852851
BinOp::FloorDivide => {
853-
if *r == 0.0 {
854-
return None;
855-
}
856-
(l / r).floor()
852+
// Float floor division uses runtime semantics; skip folding
853+
return None;
857854
}
858855
BinOp::Remainder => {
859-
if *r == 0.0 {
860-
return None;
861-
}
862-
// Python float modulo: a - b * floor(a/b)
863-
l - r * (l / r).floor()
856+
// Float modulo uses fmod() at runtime; Rust arithmetic differs
857+
return None;
864858
}
865859
BinOp::Power => l.powf(*r),
866860
_ => return None,
@@ -1491,8 +1485,8 @@ impl CodeInfo {
14911485
/// Optimize LOAD_FAST to LOAD_FAST_BORROW where safe.
14921486
///
14931487
/// insert_superinstructions (flowgraph.c): Combine STORE_FAST + LOAD_FAST →
1494-
/// STORE_FAST_LOAD_FAST. Must run BEFORE optimize_load_fast_borrow so that
1495-
/// the borrow pass sees the combined instruction (matching flowgraph.c order).
1488+
/// STORE_FAST_LOAD_FAST. Currently disabled pending VM stack null investigation.
1489+
#[allow(dead_code)]
14961490
fn combine_store_fast_load_fast(&mut self) {
14971491
for block in &mut self.blocks {
14981492
let mut i = 0;
@@ -1505,6 +1499,13 @@ impl CodeInfo {
15051499
i += 1;
15061500
continue;
15071501
};
1502+
// Skip if instructions are on different lines (matching make_super_instruction)
1503+
let line1 = curr.location.line;
1504+
let line2 = next.location.line;
1505+
if line1 != line2 {
1506+
i += 1;
1507+
continue;
1508+
}
15081509
let idx1 = u32::from(curr.arg);
15091510
let idx2 = u32::from(next.arg);
15101511
if idx1 < 16 && idx2 < 16 {
@@ -1514,8 +1515,10 @@ impl CodeInfo {
15141515
}
15151516
.into();
15161517
block.instructions[i].arg = OpArg::new(packed);
1517-
block.instructions.remove(i + 1);
1518-
// Don't advance — check if next pair can also be combined
1518+
// Replace second instruction with NOP (CPython: INSTR_SET_OP0(inst2, NOP))
1519+
block.instructions[i + 1].instr = Instruction::Nop.into();
1520+
block.instructions[i + 1].arg = OpArg::new(0);
1521+
i += 2; // skip the NOP
15191522
} else {
15201523
i += 1;
15211524
}

‎crates/compiler-core/src/bytecode.rs‎

Lines changed: 66 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -135,6 +135,72 @@ pub fn decode_exception_table(table: &[u8]) -> Vec<ExceptionTableEntry> {
135135
entries
136136
}
137137

138+
/// Parse linetable to build a boolean mask indicating which code units
139+
/// have NO_LOCATION (line == -1). Returns a Vec<bool> of length `num_units`.
140+
pub fn build_no_location_mask(linetable: &[u8], num_units: usize) -> Vec<bool> {
141+
let mut mask = Vec::new();
142+
mask.resize(num_units, false);
143+
let mut pos = 0;
144+
let mut unit_idx = 0;
145+
146+
while pos < linetable.len() && unit_idx < num_units {
147+
let header = linetable[pos];
148+
pos += 1;
149+
let code = (header >> 3) & 0xf;
150+
let length = ((header & 7) + 1) as usize;
151+
152+
let is_no_location = code == PyCodeLocationInfoKind::None as u8;
153+
154+
// Skip payload bytes based on location kind
155+
match code {
156+
0..=9 => pos += 1, // Short forms: 1 byte payload
157+
10..=12 => pos += 2, // OneLine forms: 2 bytes payload
158+
13 => {
159+
// NoColumns: signed varint (line delta)
160+
while pos < linetable.len() {
161+
let b = linetable[pos];
162+
pos += 1;
163+
if b & 0x40 == 0 {
164+
break;
165+
}
166+
}
167+
}
168+
14 => {
169+
// Long form: signed varint (line delta) + 3 unsigned varints
170+
// line_delta
171+
while pos < linetable.len() {
172+
let b = linetable[pos];
173+
pos += 1;
174+
if b & 0x40 == 0 {
175+
break;
176+
}
177+
}
178+
// end_line_delta, col+1, end_col+1
179+
for _ in 0..3 {
180+
while pos < linetable.len() {
181+
let b = linetable[pos];
182+
pos += 1;
183+
if b & 0x40 == 0 {
184+
break;
185+
}
186+
}
187+
}
188+
}
189+
15 => {} // None: no payload
190+
_ => {}
191+
}
192+
193+
for _ in 0..length {
194+
if unit_idx < num_units {
195+
mask[unit_idx] = is_no_location;
196+
unit_idx += 1;
197+
}
198+
}
199+
}
200+
201+
mask
202+
}
203+
138204
/// CPython 3.11+ linetable location info codes
139205
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
140206
#[repr(u8)]

‎crates/jit/src/instructions.rs‎

Lines changed: 14 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -736,6 +736,20 @@ impl<'a, 'b> FunctionCompiler<'a, 'b> {
736736
let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
737737
self.store_variable(var_num.get(arg), val)
738738
}
739+
Instruction::StoreFastLoadFast { var_nums } => {
740+
let oparg = var_nums.get(arg);
741+
let (store_idx, load_idx) = oparg.indexes();
742+
let val = self.stack.pop().ok_or(JitCompileError::BadBytecode)?;
743+
self.store_variable(store_idx, val)?;
744+
let local = self.variables[load_idx]
745+
.as_ref()
746+
.ok_or(JitCompileError::BadBytecode)?;
747+
self.stack.push(JitValue::from_type_and_value(
748+
local.ty.clone(),
749+
self.builder.use_var(local.var),
750+
));
751+
Ok(())
752+
}
739753
Instruction::StoreFastStoreFast { var_nums } => {
740754
let oparg = var_nums.get(arg);
741755
let (idx1, idx2) = oparg.indexes();

‎crates/vm/src/frame.rs‎

Lines changed: 32 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -1755,12 +1755,6 @@ impl ExecutingFrame<'_> {
17551755
exc_tb: PyObjectRef,
17561756
) -> PyResult<ExecutionResult> {
17571757
self.monitoring_mask = vm.state.monitoring_events.load();
1758-
// Reset prev_line so that LINE monitoring events fire even if
1759-
// the exception handler is on the same line as the yield point.
1760-
// In CPython, _Py_call_instrumentation_line has a special case
1761-
// for RESUME: it fires LINE even when prev_line == current_line.
1762-
// Since gen_throw bypasses RESUME, we reset prev_line instead.
1763-
*self.prev_line = 0;
17641758
if let Some(jen) = self.yield_from_target() {
17651759
// Check if the exception is GeneratorExit (type or instance).
17661760
// For GeneratorExit, close the sub-iterator instead of throwing.
@@ -1796,7 +1790,10 @@ impl ExecutingFrame<'_> {
17961790
self.push_value(vm.ctx.none());
17971791
vm.contextualize_exception(&err);
17981792
return match self.unwind_blocks(vm, UnwindReason::Raising { exception: err }) {
1799-
Ok(None) => self.run(vm),
1793+
Ok(None) => {
1794+
*self.prev_line = 0;
1795+
self.run(vm)
1796+
}
18001797
Ok(Some(result)) => Ok(result),
18011798
Err(exception) => Err(exception),
18021799
};
@@ -1838,7 +1835,10 @@ impl ExecutingFrame<'_> {
18381835
self.push_value(vm.ctx.none());
18391836
vm.contextualize_exception(&err);
18401837
match self.unwind_blocks(vm, UnwindReason::Raising { exception: err }) {
1841-
Ok(None) => self.run(vm),
1838+
Ok(None) => {
1839+
*self.prev_line = 0;
1840+
self.run(vm)
1841+
}
18421842
Ok(Some(result)) => Ok(result),
18431843
Err(exception) => Err(exception),
18441844
}
@@ -1906,7 +1906,13 @@ impl ExecutingFrame<'_> {
19061906
self.push_value(vm.ctx.none());
19071907

19081908
match self.unwind_blocks(vm, UnwindReason::Raising { exception }) {
1909-
Ok(None) => self.run(vm),
1909+
Ok(None) => {
1910+
// Reset prev_line so that the first instruction in the handler
1911+
// fires a LINE event. In CPython, gen_send_ex re-enters the
1912+
// eval loop which reinitializes its local prev_instr tracker.
1913+
*self.prev_line = 0;
1914+
self.run(vm)
1915+
}
19101916
Ok(Some(result)) => Ok(result),
19111917
Err(exception) => {
19121918
// Fire PY_UNWIND: exception escapes the generator frame.
@@ -9440,20 +9446,25 @@ impl ExecutingFrame<'_> {
94409446
Ok(vm.ctx.new_tuple(list.borrow_vec().to_vec()).into())
94419447
}
94429448
bytecode::IntrinsicFunction1::StopIterationError => {
9443-
// Convert StopIteration to RuntimeError
9444-
// Used to ensure async generators don't raise StopIteration directly
9445-
// _PyGen_FetchStopIterationValue
9446-
// Use fast_isinstance to handle subclasses of StopIteration
9449+
// Convert StopIteration to RuntimeError (PEP 479)
9450+
// Returns the exception object; RERAISE will re-raise it
94479451
if arg.fast_isinstance(vm.ctx.exceptions.stop_iteration) {
9448-
Err(vm.new_runtime_error("coroutine raised StopIteration"))
9452+
let flags = &self.code.flags;
9453+
let msg = if flags
9454+
.contains(bytecode::CodeFlags::COROUTINE | bytecode::CodeFlags::GENERATOR)
9455+
{
9456+
"async generator raised StopIteration"
9457+
} else if flags.contains(bytecode::CodeFlags::COROUTINE) {
9458+
"coroutine raised StopIteration"
9459+
} else {
9460+
"generator raised StopIteration"
9461+
};
9462+
let err = vm.new_runtime_error(msg);
9463+
err.set___cause__(arg.downcast().ok());
9464+
Ok(err.into())
94499465
} else {
9450-
// If not StopIteration, just re-raise the original exception
9451-
Err(arg.downcast().unwrap_or_else(|obj| {
9452-
vm.new_runtime_error(format!(
9453-
"unexpected exception type: {:?}",
9454-
obj.class()
9455-
))
9456-
}))
9466+
// Not StopIteration, pass through for RERAISE
9467+
Ok(arg)
94579468
}
94589469
}
94599470
bytecode::IntrinsicFunction1::AsyncGenWrap => {

‎crates/vm/src/stdlib/_symtable.rs‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -174,6 +174,7 @@ mod _symtable {
174174
.symtable
175175
.sub_tables
176176
.iter()
177+
.filter(|t| !t.comp_inlined)
177178
.map(|t| to_py_symbol_table(t.clone()).into_pyobject(vm))
178179
.collect();
179180
Ok(children)

‎crates/vm/src/stdlib/sys/monitoring.rs‎

Lines changed: 12 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -368,6 +368,9 @@ pub fn instrument_code(code: &PyCode, events: u32) {
368368
// is_line_start[i] = true if position i should have INSTRUMENTED_LINE
369369
let mut is_line_start = vec![false; len];
370370

371+
// Build NO_LOCATION mask from linetable
372+
let no_loc_mask = bytecode::build_no_location_mask(&code.code.linetable, len);
373+
371374
// First pass: mark positions where the source line changes
372375
let mut prev_line: Option<u32> = None;
373376
for (i, unit) in code
@@ -395,6 +398,10 @@ pub fn instrument_code(code: &PyCode, events: u32) {
395398
) {
396399
continue;
397400
}
401+
// Skip NO_LOCATION instructions
402+
if no_loc_mask.get(i).copied().unwrap_or(false) {
403+
continue;
404+
}
398405
if let Some((loc, _)) = code.code.locations.get(i) {
399406
let line = loc.line.get() as u32;
400407
let is_new = prev_line != Some(line);
@@ -445,6 +452,7 @@ pub fn instrument_code(code: &PyCode, events: u32) {
445452
if let Some(target_idx) = target
446453
&& target_idx < len
447454
&& !is_line_start[target_idx]
455+
&& !no_loc_mask.get(target_idx).copied().unwrap_or(false)
448456
{
449457
let target_op = code.code.instructions[target_idx].op;
450458
let target_base = target_op.to_base().map_or(target_op, |b| b);
@@ -465,7 +473,10 @@ pub fn instrument_code(code: &PyCode, events: u32) {
465473
// Third pass: mark exception handler targets as line starts.
466474
for entry in bytecode::decode_exception_table(&code.code.exceptiontable) {
467475
let target_idx = entry.target as usize;
468-
if target_idx < len && !is_line_start[target_idx] {
476+
if target_idx < len
477+
&& !is_line_start[target_idx]
478+
&& !no_loc_mask.get(target_idx).copied().unwrap_or(false)
479+
{
469480
let target_op = code.code.instructions[target_idx].op;
470481
let target_base = target_op.to_base().map_or(target_op, |b| b);
471482
if !matches!(target_base, Instruction::PopIter)

0 commit comments

Comments
 (0)
Back | FazBrowse Home | New Git URL