Pharo test defects

Debugger-kernel-skips

State
Partly fixed: 3 tests repaired in the image; debugger stepping not repaired; stock Cog needs a Cog change; review not accepted
Defect in
the Pharo image
Tests
4
Fix
image fix 20-Debugger-kernel-skips.st
Upstream repository
pharo-project/pharo

Open: the debugger still steps with the old stop points (shouldStepStopAt:), because 11 tests of the external Sindarin package (SindarinDebuggerTest) fail with the new stop points. A decision is needed: change Sindarin, or keep the two stop sets. The test CodeSimulationTest>>testErrorCodeNotFound passes on stock Cog only with the Cog change for primitive 218 (see the Cog section).

Record

DebugInfoTest: the three testNotStop* tests are restored with their original assertions and only the 'self skip' and the 'only valid when' comment removed. OnlineSourceDebugInfo>>shouldStopAt: is repaired: it now stops at every return and at the first bytecode of each message or assignment node of the source, not at compiler-inserted stores, comparisons, increments, jumps or closure creation. Measured side effect: the only sender is DebugSession>>stepToFirstInterestingBytecodeInContext:, and SindarinDebuggerTest (external package) steps over the old stop points; with the strict set it dropped from 87 to 76 passes (11 tests fail or error) on both VMs. So the old stop set is kept under the new name shouldStepStopAt: (added to OnlineSourceDebugInfo and OfflineSourceDebugInfo) and DebugSession uses that; SindarinDebuggerTest is back to 87 on both VMs. Moving the debugger to the strict stops needs a Sindarin change first (blockers). CodeSimulationTest>>testErrorCodeNotFound: the skip is removed. The real defect is a VM divergence: on stock Cog a missing named primitive gives #'not found' when called, but Context>>doPrimitive: 117 (VM primitive 218) gives nil (Cog sends -1). On our VM both gave nil, so the test only passed by accident (nil equals nil) and our VM did not match Cog for the real call. I changed a private copy of our VM so both give #'not found', as Cog does for the real call; the test passes 3 of 3 on that build. Stock Cog fails the test (Got #'not found' instead of nil) until the Cog one-line change below is made; I did not build Cog.

Test Defect in State Cause
DebugInfoTest>>testNotStopAtAllButFirstBytecodeOfOptimizedSend image-code repaired OnlineSourceDebugInfo>>shouldStopAt: stopped at compiler-inserted stores, sends and jumps of the inlined to:do: ('for now' in the source). Repaired: stop only at returns and at the first bytecode of message and assignment nodes. Test only loses the skip.
DebugInfoTest>>testNotStopAtConstantBlockCreation image-code repaired shouldStopAt: stopped at the closure-creation bytecode (isSourceBlockCreation:). No longer a stop point; test only loses the skip.
DebugInfoTest>>testNotStopAtFullBlockCreation image-code repaired shouldStopAt: stopped at the fullClosure bytecode. No longer a stop point; test only loses the skip.
CodeSimulationTest>>testErrorCodeNotFound both-vms needs a VM change A named primitive that does not exist: the real call gives error code #'not found' on Cog (PrimErrNotFound 11) but nil on our VM (primitiveExternalCall returned Failure with no code). Simulation through Context>>doPrimitive:method:receiver:args: 117 gives nil on both VMs (ours: primFailCode_ = -1 always, Primitives.cpp primitiveDoNamedPrimitiveWithArgs; Cog: StackInterpreterPrimitives>>primitiveDoNamedPrimitiveWithArgs line 916, primitiveFailFor: -1). The test wants both to be equal. On unpatched ours the test passes only because nil equals nil (real call gives nil as well). Skip removed from the test; the assertions are unchanged.

Regression check: Pass counts (P/F/E/S) with the base image vs the fix image, run on both VMs (ours = vm-base, Cog = native arm64 v12.0.6). Final fix image: DebugInfoTest base 68P/3S, fix 71P/0S on both VMs. SindarinDebuggerTest base 87P, fix 87P on both VMs (with the first attempt, the strict stops used by DebugSession, it dropped to 76P/7F/4E on both VMs; that is why shouldStepStopAt: exists). Unchanged base vs fix on both VMs: DebugSessionContextsTest 2, DebugSessionContexts2Test 3, DebugSessionExceptionTest 3, DebuggerModelTest 7, AssignmentAndLiteralDebuggerTest 6, InstructionStreamSteppingTest 6, SindarinDebugSessionTest 3, StDebuggerContextTest 14, StMorphicDebugSessionTest 2, StDebuggerTest 62P/6S (one flaky fail testUpdateExtensionSubscription on Cog showed up on base too; 2 of 3 reruns pass on both), DebuggerTest 0 tests. CodeSimulationTest: ours base 8P/1S, fix 9P; Cog base 8P/1S, fix 8P/1F (the Cog failure is testErrorCodeNotFound, see vmChange). VM change, private build vs vm-base, same fix image, ours only: FFICalloutTest 6/6, FFICalloutAPITest 18/18, FFIFunctionResolutionTest 19/19, FFIStringCalloutTest 13/13, FFIExternalStructureTest 12/12, FFITypesTest 15/15, FFICallbackTest 2/2, FileAttributesPluginPrimsTest 6/6, CodeSimulationTest 9/9, DebuggerModelTest 7/7, SindarinDebuggerTest 87/87, ByteArrayTest 13/13, StringTest 433/433, LargePositiveIntegerTest 19/19, FloatTest 60P/1S both, CairoLibraryTest 1/1, ProcessTest 47/47, BlockClosureTest 29P/2S both, DateAndTimeTest 59/59, ZipArchiveTest 15 vs 14 once, then 15 vs 15 in 3 reruns (parallel runs shared /tmp/testfiles: flake). SocketTest has no tests in this runner. Not run: the whole Pharo suite, GUI tests of StDebugger beyond StDebuggerTest, the JIT-off VM.

VM change: Both changes are for a person to review before any pull request. I did not edit the iospharo repository ; I changed a private copy (<work directory>) and built it with cmake -G Ninja -DCMAKE_BUILD_TYPE=Release -DPHARO_ASM_TRAMPOLINE=ON -DPHARO_WITH_CRYPTO=ON -DPHARO_DIAG_KNOBS=OFF; binary <local work directory> unified diff: <local work directory> (70 lines, against HEAD 9b4e3107, files src/vm/Primitives.cpp and src/vm/Interpreter.hpp).

OUR VM. (1) Interpreter.hpp: add static constexpr int PrimErrNotFound_ = 11; (value from src/vm/plugins/sqVirtualMachine.h PrimErrNotFound). (2) Primitives.cpp primitiveExternalCall: (a) in the miss-cache hit if (extEntry.missing) set primFailCode_ = PrimErrNotFound_ before the Failure return; (b) at the end, where a named-primitive spec (Array of 4 with a byte-object name) was found and not resolved, set if (primFailCode_ == 0) primFailCode_ = PrimErrNotFound_; and move the PHARO_NO_EXTCALL_MISS_CACHE check so that it guards only the caching, not the code. (3) Primitives.cpp primitiveDoNamedPrimitiveWithArgs (prim 218): keep the inner failure code (const int innerCode = primFailCode_; before popN) and set primFailCode_ = (innerCode > 1) ? innerCode : -1; instead of always -1. This is what Cog does: Cog keeps the code of the failed external primitive and maps only the generic code 1 to -1. Defect before: Primitives.cpp primitiveExternalCall ended in a bare return PrimitiveResult::Failure (primFailCode_ stays 0), so <primitive: 'dooo' module: 'bar' error: code> got code = nil; Cog gives #'not found'.

Minimal reproducer (Smalltalk, evalfile): | r | r := CodeSimulationTest new veryBasicAt: 1. { r. (Context sender: nil receiver: nil method: Object >> #at: arguments: #(10)) push: nil; push: 500; doPrimitive: 117 method: CodeSimulationTest >> #veryBasicAt: receiver: CodeSimulationTest new args: #(999) } Our VM before: {nil. {token. nil}}. Our VM patched: {#'not found'. {token. #'not found'}}. Stock Cog v12.0.6 (arm64): {#'not found'. {token. nil}}.

COG (proposal, not built, not measured). pharo-vm/smalltalksrc/VMMaker/StackInterpreterPrimitives.class.st line 916 in primitiveDoNamedPrimitiveWithArgs: addr = 0 ifTrue: [ ^ self primitiveFailFor: -1 ]. \"could not find function; answer generic failure (see below)\". Proposal: addr = 0 ifTrue: [ ^ self primitiveFailFor: PrimErrNotFound ]. primitiveExternalCall already fails with PrimErrNotFound for the same case (see its class comment), and Context>>tryNamedPrimitiveIn:for:withArgs: (Kernel-CodeModel/Context.class.st line 2110) passes a non-integer error code on as the code of the failure token, so the simulation then answers #'not found' like the real call. With this change CodeSimulationTest>>testErrorCodeNotFound should pass on Cog; this is derived from reading the sources and the one measurement above, not from a built Cog. The generated C is in the VMMaker output (cointerp.c, primitiveDoNamedPrimitiveWithArgs).

Open points: 1) The debugger still uses the OLD (compiler-level) stop points through shouldStepStopAt:. The user-visible stepping granularity is not repaired, only shouldStopAt: and its tests are. Moving DebugSession to shouldStopAt: needs the Sindarin package (external, not in the Pharo sources (pharo-project/pharo)) to be changed: with the strict set these 11 SindarinDebuggerTest tests fail on both VMs: testCanStillExecuteWhenAimedNodePcIsAfterInAnyContext, testCanStillExecuteWhenAimedNodePcIsBeforeInAnyContext, testMoveToNodeWhenNodeIsInBlockThatCreatesContextAndBlockCreationIsFirstBytecodeInFirstStatement, testMoveToNodeWhenNodeIsInBlockThatCreatesContextAndBlockHasBeenCreated, testMoveToNodeWhenNodeIsInBlockThatCreatesContextAndBlockHasBeenCreatedBackward, testMoveToNodeWhenNodeIsInIfTrueIfFalseBlock, testSkipAssignmentWithStoreIntoBytecodePushesReplacementValueButNotWithPopIntoBytecode, testSkipStepsMethodNodes, testSkipUpToNodeInEvaluatedBlock, testSkipUpToNodeStopsOnImplicitReturnIfAimedNodeCanStillBeExecuted, testSkipUpToNodeStopsOnReturnNodes. The owner should decide whether Sindarin is to be changed or the split stays. 2) CodeSimulationTest>>testErrorCodeNotFound passes on our VM only with the VM change (which I made and built only in a private copy under scratchpad/<work directory>; the repository was not touched) and fails on stock Cog until the one-line Cog change is made; I could not build a patched Cog (the VMMaker generation and the Cog build were not attempted), so the Cog side is a proposal from source reading plus the measured failure text. The fix file applies the test change on both VMs, so with the skip removed the test will fail on stock Cog until Cog is changed. 3) The DebugInfoTest runs use the SUnit runner's single default parametrization; I checked cached=true and cached=false by an eval loop for all testStop*/testNotStop* tests (all pass on both VMs).

Upstream note: Pharo (Debugger/DebugInfo): "Make OnlineSourceDebugInfo>>shouldStopAt: stop only at source stop points and enable three DebugInfoTest tests". shouldStopAt: answers true for every return and for the first bytecode of each message or assignment node; the compiler-inserted store, comparison, increment and jump bytecodes of inlined loops and the closure-creation bytecodes are no stop points. The three DebugInfoTest testNotStop* tests lose their 'self skip'. Note for review: DebugSession>>stepToFirstInterestingBytecodeInContext: is the only sender and Sindarin (external) tests step over the old stop points (11 tests of SindarinDebuggerTest fail with the strict set), so the proposal keeps the old set as shouldStepStopAt: for DebugSession until Sindarin changes. Separate, for the Cog people (owner reviews first, no AI-written PR before that): in StackInterpreterPrimitives>>primitiveDoNamedPrimitiveWithArgs answer PrimErrNotFound instead of -1 when the function is not found, so the simulation in Context>>doPrimitive:method:receiver:args: gives the same error code as the real call, and enable CodeSimulationTest>>testErrorCodeNotFound.

Reviewer, required changes: 1) CodeSimulationTest>>testErrorCodeNotFound must pass 3 of 3 on both VMs with the images the fix file produces. Either (a) get the Cog change reviewed by the owner, built, and measured on a patched Cog. The patch is primitiveFailFor: PrimErrNotFound in primitiveDoNamedPrimitiveWithArgs. Report the 3 of 3 pass on that Cog and apply the VM patch to our VM in the repository. Or (b) leave the skip in until both VMs are fixed. Do not remove the skip while the test fails on Cog. 2) The user-visible debugger stepping is not repaired, because DebugSession uses the old stop set (shouldStepStopAt:). Either make the Sindarin tests pass with the strict set, or document that clearly as a deferred item with an owner decision. 3) Re-run the regression comparison, base against fix, on both VMs.

Results

Last full sweeps of 2026-11-17: iospharo (sweep14-new14) and stock Cog with the Cog changes (sweepcogp14-new10), with all image fixes. "Before" is the state of the test before the repairs. The Stock Cog column has a value only where the record measured stock Cog: "PASS 3 of 3 (repair run)" is the check of each repair on stock Cog v12.0.6 with the fix entry; "-" is not measured separately.

TestBeforeStateiospharo VMPatched CogStock Cog
DebugInfoTest>>testNotStopAtAllButFirstBytecodeOfOptimizedSendSKIPrepairedPASS 2xPASS 2xPASS 3 of 3 (repair run)
DebugInfoTest>>testNotStopAtConstantBlockCreationSKIPrepairedPASS 2xPASS 2xPASS 3 of 3 (repair run)
DebugInfoTest>>testNotStopAtFullBlockCreationSKIPrepairedPASS 2xPASS 2xPASS 3 of 3 (repair run)
CodeSimulationTest>>testErrorCodeNotFoundSKIPneeds a VM changePASSPASSFAIL

Test

Run the tests in a Pharo 14 image (build 791). Before the fix they skip, fail or carry the expected-failure mark.

"Run in a Playground of a Pharo 14 image (Do it and print each line)."
((CodeSimulationTest selector: #testErrorCodeNotFound) run) printString.
((DebugInfoTest selector: #testNotStopAtAllButFirstBytecodeOfOptimizedSend) run) printString.
((DebugInfoTest selector: #testNotStopAtConstantBlockCreation) run) printString.
((DebugInfoTest selector: #testNotStopAtFullBlockCreation) run) printString.

Source of the tests before the fix

CodeSimulationTest>>testErrorCodeNotFound before the fix (Pharo 14 build 791)
testErrorCodeNotFound
	| ctx result resultSimu |
	self skip.

	Smalltalk vm isRunningCog ifFalse: [ ^ self ].

	result := self veryBasicAt: 1.

	ctx := Context
		sender: nil
		receiver: nil
		method: Object >> #at:
		arguments: #(10).

	resultSimu := ctx
		push: nil;
		push: 500;
		doPrimitive: 117
			method: self class >> #veryBasicAt:
			receiver: self
			args: #(999).

	self assert: resultSimu isArray.
	self assert: Context primitiveFailToken first identicalTo: resultSimu first.
	self assert: result equals: resultSimu second
DebugInfoTest>>testNotStopAtAllButFirstBytecodeOfOptimizedSend before the fix (Pharo 14 build 791)
testNotStopAtAllButFirstBytecodeOfOptimizedSend

	| debugInfo methodToTest send todoPCs |
	
	"This test is only valid when shouldStopAt: does not stop at
	  - compiler only inserted stores
	  - closure creations"
	self skip.
	
	methodToTest := self class >> #methodWithOptimizedSend.
	debugInfo := self newDebugInfoFor: methodToTest.

	"a to:do: send should stop at the to:do: point but not in the intermediate steps"
	send := methodToTest ast statements first.
	todoPCs := send methodNode pcsForNode: send.
	self assert: todoPCs size > 1.

	todoPCs allButFirst do: [ :otherPC |
		self deny: (debugInfo shouldStopAt: otherPC) ]
DebugInfoTest>>testNotStopAtConstantBlockCreation before the fix (Pharo 14 build 791)
testNotStopAtConstantBlockCreation

	| debugInfo methodToTest blockNode blockCreationPC |
	
	"This test is only valid when shouldStopAt: does not stop at
	  - compiler only inserted stores
	  - closure creations"
	self skip.
	
	methodToTest := self class >> #methodWithConstantBlockReturn.
	debugInfo := self newDebugInfoFor: methodToTest.

	blockNode := methodToTest ast statements first.
	blockCreationPC := (blockNode methodNode pcsForNode: blockNode) first.

	self deny: (debugInfo shouldStopAt: blockCreationPC)
DebugInfoTest>>testNotStopAtFullBlockCreation before the fix (Pharo 14 build 791)
testNotStopAtFullBlockCreation

	| debugInfo methodToTest blockNode blockCreationPCs |
	
	"This test is only valid when shouldStopAt: does not stop at
	  - compiler only inserted stores
	  - closure creations"
	self skip.
	
	methodToTest := self class >> #methodWithFullBlockReturn.
	debugInfo := self newDebugInfoFor: methodToTest.

	blockNode := methodToTest ast statements first.
	"A block may have many PCs: the creation of the block but also the creation of the temp verctor and the copied vars
	None of them are stop points."
	blockCreationPCs := blockNode methodNode pcsForNode: blockNode.
	self assert: blockCreationPCs notEmpty.

	blockCreationPCs do: [ :e | self deny: (debugInfo shouldStopAt: e) ]

Fix

How to apply an entries file: file in 00-header.st and the entries file as one chunk (the iospharo script scripts/gen-image-fixes.py makes that chunk). Each entry checks for the defect first and prints FIXED, ADDED or SKIP. Download 00-header.st.

20-Debugger-kernel-skips.st (download)
"Debugger-kernel-skips.

1. OnlineSourceDebugInfo>>shouldStopAt: stopped at every send, store, jump and
closure-creation bytecode, the ones that the compiler inserts included (the
comments of isSourceSend:, isSourceStore: and isSourceBlockCreation: say 'for
now').  DebugInfoTest has three tests of the intended behavior
(testNotStopAtAllButFirstBytecodeOfOptimizedSend, testNotStopAtConstantBlockCreation,
testNotStopAtFullBlockCreation); they said 'self skip' until shouldStopAt: no
longer stops at compiler-inserted stores and closure creations.  The fix:
shouldStopAt: stops at every return (the compiler inserts them, the debugger
must stop there) and at the FIRST bytecode of each message or assignment node
of the source.  Bytecodes that the compiler adds around such a node (the store
of the loop variable, the comparison, the increment and the jumps of an inlined
to:do:, the creation of a closure) are no stop points.  The three tests lose
the skip and their 'only valid when' comment; the assertions are unchanged.

The debugger (DebugSession>>stepToFirstInterestingBytecodeInContext:) is the
only sender of shouldStopAt:, and the Sindarin debugger (an external package,
SindarinDebuggerTest) steps over exactly the old stop points: with the strict
set 11 SindarinDebuggerTest tests that pass now would fail (testMoveToNode...
BlockHasBeenCreated, testSkipAssignment..., testSkipUpToNodeStopsOnReturnNodes
and others; their names say block creation is a step).  So the old stop set
stays available, under its own name shouldStepStopAt:, and DebugSession uses
that.  Moving DebugSession to the strict set needs the Sindarin package to be
changed first.

2. CodeSimulationTest>>testErrorCodeNotFound said 'self skip'.  It checks that
the simulation of a named primitive that does not exist gives the same error
code as the real primitive (#'not found').  The skip is removed.  It passes on
our VM with the VM change of the report (Primitives.cpp, primitiveExternalCall
and primitiveDoNamedPrimitiveWithArgs) and needs the Cog change of the report
to pass on stock Cog."

fix value: #OnlineSourceDebugInfo value: #shouldStopAt: value: [ :src | (src includesSubstring: 'isSourceBlockCreation:') ]
	value: 'shouldStopAt: aBytecodePC

	"Stop at all returns (the compiler inserts some, and the debugger has to stop there)
	 and at the first bytecode of each message or assignment node of the source.
	 The other bytecodes of the expansion of such a node are compiler-inserted and are
	 not stop points: the store of the loop variable, the comparison, the increment and
	 the jumps of an inlined to:do:, the closure creation, and the pushes of copied variables."
	| node |
	(self isSourceReturn: aBytecodePC) ifTrue: [ ^ true ].
	node := self privateSourceNodeForPC: aBytecodePC.
	node ifNil: [ ^ false ].
	(node isMessage or: [ node isAssignment ]) ifFalse: [ ^ false ].
	^ (bytecodeToASTCache firstBcOffsetForNode: node) = aBytecodePC'.

fix value: #DebugInfoTest value: #testNotStopAtAllButFirstBytecodeOfOptimizedSend value: [ :src | src includesSubstring: 'self skip' ]
	value: 'testNotStopAtAllButFirstBytecodeOfOptimizedSend

	| debugInfo methodToTest send todoPCs |
	methodToTest := self class >> #methodWithOptimizedSend.
	debugInfo := self newDebugInfoFor: methodToTest.

	"a to:do: send should stop at the to:do: point but not in the intermediate steps"
	send := methodToTest ast statements first.
	todoPCs := send methodNode pcsForNode: send.
	self assert: todoPCs size > 1.

	todoPCs allButFirst do: [ :otherPC |
		self deny: (debugInfo shouldStopAt: otherPC) ]'.

fix value: #DebugInfoTest value: #testNotStopAtConstantBlockCreation value: [ :src | src includesSubstring: 'self skip' ]
	value: 'testNotStopAtConstantBlockCreation

	| debugInfo methodToTest blockNode blockCreationPC |
	methodToTest := self class >> #methodWithConstantBlockReturn.
	debugInfo := self newDebugInfoFor: methodToTest.

	blockNode := methodToTest ast statements first.
	blockCreationPC := (blockNode methodNode pcsForNode: blockNode) first.

	self deny: (debugInfo shouldStopAt: blockCreationPC)'.

fix value: #DebugInfoTest value: #testNotStopAtFullBlockCreation value: [ :src | src includesSubstring: 'self skip' ]
	value: 'testNotStopAtFullBlockCreation

	| debugInfo methodToTest blockNode blockCreationPCs |
	methodToTest := self class >> #methodWithFullBlockReturn.
	debugInfo := self newDebugInfoFor: methodToTest.

	blockNode := methodToTest ast statements first.
	"A block may have many PCs: the creation of the block but also the creation of the temp verctor and the copied vars
	None of them are stop points."
	blockCreationPCs := blockNode methodNode pcsForNode: blockNode.
	self assert: blockCreationPCs notEmpty.

	blockCreationPCs do: [ :e | self deny: (debugInfo shouldStopAt: e) ]'.

fix value: #CodeSimulationTest value: #testErrorCodeNotFound value: [ :src | src includesSubstring: 'self skip' ]
	value: 'testErrorCodeNotFound
	| ctx result resultSimu |
	Smalltalk vm isRunningCog ifFalse: [ ^ self ].

	result := self veryBasicAt: 1.

	ctx := Context
		sender: nil
		receiver: nil
		method: Object >> #at:
		arguments: #(10).

	resultSimu := ctx
		push: nil;
		push: 500;
		doPrimitive: 117
			method: self class >> #veryBasicAt:
			receiver: self
			args: #(999).

	self assert: resultSimu isArray.
	self assert: Context primitiveFailToken first identicalTo: resultSimu first.
	self assert: result equals: resultSimu second'.

add value: #OnlineSourceDebugInfo value: #shouldStepStopAt: value: 'api'
	value: 'shouldStepStopAt: aBytecodePC

	"The stop points of the stepping of the debugger: every send, return, store, closure creation
	 and jump bytecode, the ones that the compiler inserts included.  This is the old behavior of
	 shouldStopAt:, which now answers the stop points of the source only.  The Sindarin debugger
	 steps over these stop points.  Merge this with shouldStopAt: when Sindarin is changed."

	^ (self isSourceSend: aBytecodePC) or: [
			  (self isSourceReturn: aBytecodePC) or: [
				  (self isSourceStore: aBytecodePC) or: [ (self isSourceBlockCreation: aBytecodePC) or: [ self isSourceJump: aBytecodePC ] ] ] ]'.

fix value: #DebugSession value: #stepToFirstInterestingBytecodeInContext: value: [ :src | src includesSubstring: 'debugInfo shouldStopAt: aContext pc' ]
	value: 'stepToFirstInterestingBytecodeInContext: aContext

	| bytecodeInterpreter context debugInfo |
	aContext isDead ifTrue: [
		self error: ''Cannot step into dead context'' ].

	debugInfo := aContext method debugInfo.
	bytecodeInterpreter := InstructionStream
		                       on: aContext method
		                       pc: aContext pc.
	[ debugInfo shouldStepStopAt: aContext pc ] whileFalse: [
			context := bytecodeInterpreter interpretNextInstructionFor:
				           aContext.
			context == aContext ifFalse: [ "Caused all non-send, non-store, non-return instructions
				that may activate a method. This is today the case of mustBeBoolean.
				
				If a mustBeBoolean has been activated, we need to change contexts"
				^ context ] ].

	^ aContext'.

add value: #OfflineSourceDebugInfo value: #shouldStepStopAt: value: 'accessing'
	value: 'shouldStepStopAt: aBytecodePC

	"The stop table of an offline debug info holds the stop points of the source only, see OnlineSourceDebugInfo>>shouldStopAt:"

	^ self shouldStopAt: aBytecodePC'.

State of 2026-11-20. Made from the test records of the iospharo project (a second Pharo VM). The fixes are proposals for review.