Rodrigo Mesquita pushed to branch wip/romes/step-out-11 at Glasgow Haskell Compiler / GHC Commits: 21f1d8c3 by Rodrigo Mesquita at 2025-07-31T16:52:10+01:00 BRK_FUN with InternalBreakLocs for code-generation time breakpoints At the start of a case continuation BCO, place a BRK_FUN. This BRK_FUN uses the new "internal breakpoint location" -- allowing us to come up with a valid source location for this breakpoint that is not associated with a source-level tick. For case continuation BCOs, we use the last tick seen before it as the source location. The reasoning is described in Note [Debugger: Stepout internal break locs]. Note how T26042c, which was broken because it displayed the incorrect behavior of the previous step out when we'd end up at a deeper level than the one from which we initiated step-out, is now fixed. As of this commit, BRK_ALTS is now dead code and is thus dropped. Note [Debugger: Stepout internal break locs] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Step-out tells the interpreter to run until the current function returns to where it was called from, and stop there. This is achieved by enabling the BRK_FUN found on the first RET_BCO frame on the stack (See [Note Debugger: Step-out]). Case continuation BCOs (which select an alternative branch) must therefore be headed by a BRK_FUN. An example: f x = case g x of <--- end up here 1 -> ... 2 -> ... g y = ... <--- step out from here - `g` will return a value to the case continuation BCO in `f` - The case continuation BCO will receive the value returned from g - Match on it and push the alternative continuation for that branch - And then enter that alternative. If we step-out of `g`, the first RET_BCO on the stack is the case continuation of `f` -- execution should stop at its start, before selecting an alternative. (One might ask, "why not enable the breakpoint in the alternative instead?", because the alternative continuation is only pushed to the stack *after* it is selected by the case cont. BCO) However, the case cont. BCO is not associated with any source-level tick, it is merely the glue code which selects alternatives which do have source level ticks. Therefore, we have to come up at code generation time with a breakpoint location ('InternalBreakLoc') to display to the user when it is stopped there. Our solution is to use the last tick seen just before reaching the case continuation. This is robust because a case continuation will thus always have a relevant breakpoint location: - The source location will be the last source-relevant expression executed before the continuation is pushed - So the source location will point to the thing you've just stepped out of - Doing :step-local from there will put you on the selected alternative (which at the source level may also be the e.g. next line in a do-block) Examples, using angle brackets (<<...>>) to denote the breakpoint span: f x = case <<g x>> {- step in here -} of 1 -> ... 2 -> ...> g y = <<...>> <--- step out from here ... f x = <<case g x of <--- end up here, whole case highlighted 1 -> ... 2 -> ...>> doing :step-local ... f x = case g x of 1 -> <<...>> <--- stop in the alternative 2 -> ... A second example based on T26042d2, where the source is a do-block IO action, optimised to a chain of `case expressions`. main = do putStrLn "hello1" <<f>> <--- step-in here putStrLn "hello3" putStrLn "hello4" f = do <<putStrLn "hello2.1">> <--- step-out from here putStrLn "hello2.2" ... main = do putStrLn "hello1" <<f>> <--- end up here again, the previously executed expression putStrLn "hello3" putStrLn "hello4" doing step/step-local ... main = do putStrLn "hello1" f <<putStrLn "hello3">> <--- straight to the next line putStrLn "hello4" Finishes #26042 - - - - - 21 changed files: - compiler/GHC/ByteCode/Asm.hs - compiler/GHC/ByteCode/Breakpoints.hs - compiler/GHC/ByteCode/Instr.hs - compiler/GHC/Linker/Loader.hs - compiler/GHC/Runtime/Debugger/Breakpoints.hs - compiler/GHC/Runtime/Eval.hs - compiler/GHC/StgToByteCode.hs - ghc/GHCi/UI.hs - rts/Disassembler.c - rts/Interpreter.c - rts/include/rts/Bytecodes.h - testsuite/tests/ghci.debugger/scripts/T26042b.stdout - testsuite/tests/ghci.debugger/scripts/T26042c.script - testsuite/tests/ghci.debugger/scripts/T26042c.stdout - + testsuite/tests/ghci.debugger/scripts/T26042d2.hs - + testsuite/tests/ghci.debugger/scripts/T26042d2.script - + testsuite/tests/ghci.debugger/scripts/T26042d2.stdout - testsuite/tests/ghci.debugger/scripts/T26042e.stdout - testsuite/tests/ghci.debugger/scripts/T26042f2.stdout - testsuite/tests/ghci.debugger/scripts/T26042g.stdout - testsuite/tests/ghci.debugger/scripts/all.T Changes: ===================================== compiler/GHC/ByteCode/Asm.hs ===================================== @@ -854,8 +854,6 @@ assembleI platform i = case i of emit_ bci_BRK_FUN [ Op p1, Op info_addr, Op info_unitid_addr , SmallOp (toW16 infox), Op np ] - BRK_ALTS active -> emit_ bci_BRK_ALTS [SmallOp (if active then 1 else 0)] - #if MIN_VERSION_rts(1,0,3) BCO_NAME name -> do np <- lit1 (BCONPtrStr name) emit_ bci_BCO_NAME [Op np] ===================================== compiler/GHC/ByteCode/Breakpoints.hs ===================================== @@ -1,4 +1,5 @@ {-# LANGUAGE RecordWildCards #-} +{-# LANGUAGE DerivingStrategies #-} -- | Breakpoint information constructed during ByteCode generation. -- @@ -15,6 +16,7 @@ module GHC.ByteCode.Breakpoints -- ** Internal breakpoint identifier , InternalBreakpointId(..), BreakInfoIndex + , InternalBreakLoc(..) -- * Operations @@ -23,7 +25,7 @@ module GHC.ByteCode.Breakpoints -- ** Source-level information operations , getBreakLoc, getBreakVars, getBreakDecls, getBreakCCS - , getBreakSourceId + , getBreakSourceId, getBreakSourceMod -- * Utils , seqInternalModBreaks @@ -165,7 +167,7 @@ data CgBreakInfo { cgb_tyvars :: ![IfaceTvBndr] -- ^ Type variables in scope at the breakpoint , cgb_vars :: ![Maybe (IfaceIdBndr, Word)] , cgb_resty :: !IfaceType - , cgb_tick_id :: !BreakpointId + , cgb_tick_id :: !(Either InternalBreakLoc BreakpointId) -- ^ This field records the original breakpoint tick identifier for this -- internal breakpoint info. It is used to convert a breakpoint -- *occurrence* index ('InternalBreakpointId') into a *definition* index @@ -173,9 +175,18 @@ data CgBreakInfo -- -- The modules of breakpoint occurrence and breakpoint definition are not -- necessarily the same: See Note [Breakpoint identifiers]. + -- + -- If there is no original tick identifier (that is, the breakpoint was + -- created during code generation), instead refer directly to the SrcSpan + -- we want to use for it. } -- See Note [Syncing breakpoint info] in GHC.Runtime.Eval +-- | Breakpoints created during code generation don't have a source-level tick +-- location. Instead, we come up with one ourselves. +newtype InternalBreakLoc = InternalBreakLoc SrcSpan + deriving newtype (Eq, Show, NFData, Outputable) + -- | Get an internal breakpoint info by 'InternalBreakpointId' getInternalBreak :: InternalBreakpointId -> InternalModBreaks -> CgBreakInfo getInternalBreak (InternalBreakpointId mod ix) imbs = @@ -196,27 +207,36 @@ assert_modules_match ibi_mod imbs_mod = -- | Get the source module and tick index for this breakpoint -- (as opposed to the module where this breakpoint occurs, which is in 'InternalBreakpointId') -getBreakSourceId :: InternalBreakpointId -> InternalModBreaks -> BreakpointId +getBreakSourceId :: InternalBreakpointId -> InternalModBreaks -> Either InternalBreakLoc BreakpointId getBreakSourceId (InternalBreakpointId ibi_mod ibi_ix) imbs = assert_modules_match ibi_mod (imodBreaks_module imbs) $ let cgb = imodBreaks_breakInfo imbs IM.! ibi_ix in cgb_tick_id cgb +-- | Get the source module for this breakpoint (where the breakpoint is defined) +getBreakSourceMod :: InternalBreakpointId -> InternalModBreaks -> Module +getBreakSourceMod (InternalBreakpointId ibi_mod ibi_ix) imbs = + assert_modules_match ibi_mod (imodBreaks_module imbs) $ + let cgb = imodBreaks_breakInfo imbs IM.! ibi_ix + in case cgb_tick_id cgb of + Left InternalBreakLoc{} -> imodBreaks_module imbs + Right BreakpointId{bi_tick_mod} -> bi_tick_mod + -- | Get the source span for this breakpoint getBreakLoc :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO SrcSpan -getBreakLoc = getBreakXXX modBreaks_locs +getBreakLoc = getBreakXXX modBreaks_locs (\(InternalBreakLoc x) -> x) -- | Get the vars for this breakpoint getBreakVars :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [OccName] -getBreakVars = getBreakXXX modBreaks_vars +getBreakVars = getBreakXXX modBreaks_vars (const []) -- | Get the decls for this breakpoint getBreakDecls :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [String] -getBreakDecls = getBreakXXX modBreaks_decls +getBreakDecls = getBreakXXX modBreaks_decls (const []) -- | Get the decls for this breakpoint -getBreakCCS :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO (String, String) -getBreakCCS = getBreakXXX modBreaks_ccs +getBreakCCS :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO (Maybe (String, String)) +getBreakCCS = getBreakXXX (fmap Just . modBreaks_ccs) (const Nothing) -- | Internal utility to access a ModBreaks field at a particular breakpoint index -- @@ -228,14 +248,17 @@ getBreakCCS = getBreakXXX modBreaks_ccs -- 'ModBreaks'. When the tick module is different, we need to look up the -- 'ModBreaks' in the HUG for that other module. -- +-- When there is no tick module (the breakpoint was generated at codegen), use +-- the function on internal mod breaks. +-- -- To avoid cyclic dependencies, we instead receive a function that looks up -- the 'ModBreaks' given a 'Module' -getBreakXXX :: (ModBreaks -> Array BreakTickIndex a) -> (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO a -getBreakXXX view lookupModule (InternalBreakpointId ibi_mod ibi_ix) imbs = +getBreakXXX :: (ModBreaks -> Array BreakTickIndex a) -> (InternalBreakLoc -> a) -> (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO a +getBreakXXX view viewInternal lookupModule (InternalBreakpointId ibi_mod ibi_ix) imbs = assert_modules_match ibi_mod (imodBreaks_module imbs) $ do let cgb = imodBreaks_breakInfo imbs IM.! ibi_ix case cgb_tick_id cgb of - BreakpointId{bi_tick_mod, bi_tick_index} + Right BreakpointId{bi_tick_mod, bi_tick_index} | bi_tick_mod == ibi_mod -> do let these_mbs = imodBreaks_modBreaks imbs @@ -244,6 +267,8 @@ getBreakXXX view lookupModule (InternalBreakpointId ibi_mod ibi_ix) imbs = -> do other_mbs <- lookupModule bi_tick_mod return $ view other_mbs ! bi_tick_index + Left l -> + return $ viewInternal l -------------------------------------------------------------------------------- -- Instances ===================================== compiler/GHC/ByteCode/Instr.hs ===================================== @@ -260,10 +260,6 @@ data BCInstr -- Breakpoints | BRK_FUN !InternalBreakpointId - -- An internal breakpoint for triggering a break on any case alternative - -- See Note [Debugger: BRK_ALTS] - | BRK_ALTS !Bool {- enabled? -} - #if MIN_VERSION_rts(1,0,3) -- | A "meta"-instruction for recording the name of a BCO for debugging purposes. -- These are ignored by the interpreter but helpfully printed by the disassmbler. @@ -458,7 +454,6 @@ instance Outputable BCInstr where = text "BRK_FUN" <+> text "<breakarray>" <+> ppr info_mod <+> ppr infox <+> text "<cc>" - ppr (BRK_ALTS active) = text "BRK_ALTS" <+> ppr active #if MIN_VERSION_rts(1,0,3) ppr (BCO_NAME nm) = text "BCO_NAME" <+> text (show nm) #endif @@ -584,7 +579,6 @@ bciStackUse OP_INDEX_ADDR{} = 0 bciStackUse SWIZZLE{} = 0 bciStackUse BRK_FUN{} = 0 -bciStackUse BRK_ALTS{} = 0 -- These insns actually reduce stack use, but we need the high-tide level, -- so can't use this info. Not that it matters much. ===================================== compiler/GHC/Linker/Loader.hs ===================================== @@ -58,6 +58,7 @@ import GHCi.RemoteTypes import GHC.Iface.Load import GHCi.Message (ConInfoTable(..), LoadedDLL) +import GHC.ByteCode.Breakpoints import GHC.ByteCode.Linker import GHC.ByteCode.Asm import GHC.ByteCode.Types @@ -1711,8 +1712,10 @@ allocateCCS interp ce mbss let count = 1 + (maybe 0 fst $ IM.lookupMax imodBreaks_breakInfo) let ccs = IM.map (\info -> - fromMaybe (toRemotePtr nullPtr) - (M.lookup (cgb_tick_id info) ccss) + case cgb_tick_id info of + Right bi -> fromMaybe (toRemotePtr nullPtr) + (M.lookup bi ccss) + Left InternalBreakLoc{} -> toRemotePtr nullPtr ) imodBreaks_breakInfo assertPpr (count == length ccs) ===================================== compiler/GHC/Runtime/Debugger/Breakpoints.hs ===================================== @@ -253,8 +253,11 @@ mkBreakpointOccurrences = do let imod = modBreaks_module $ imodBreaks_modBreaks ibrks IntMap.foldrWithKey (\info_ix cgi bmp -> do let ibi = InternalBreakpointId imod info_ix - let BreakpointId tick_mod tick_ix = cgb_tick_id cgi - extendModuleEnvWith (IntMap.unionWith (S.<>)) bmp tick_mod (IntMap.singleton tick_ix [ibi]) + case cgb_tick_id cgi of + Right (BreakpointId tick_mod tick_ix) + -> extendModuleEnvWith (IntMap.unionWith (S.<>)) bmp tick_mod (IntMap.singleton tick_ix [ibi]) + Left _ + -> bmp ) bmp0 (imodBreaks_breakInfo ibrks) -------------------------------------------------------------------------------- @@ -287,7 +290,7 @@ getCurrentBreakModule = do Nothing -> pure Nothing Just ibi -> do brks <- readIModBreaks hug ibi - return $ Just $ bi_tick_mod $ getBreakSourceId ibi brks + return $ Just $ getBreakSourceMod ibi brks ix -> Just <$> getHistoryModule hug (resumeHistory r !! (ix-1)) ===================================== compiler/GHC/Runtime/Eval.hs ===================================== @@ -151,7 +151,7 @@ getHistoryModule :: HUG.HomeUnitGraph -> History -> IO Module getHistoryModule hug hist = do let ibi = historyBreakpointId hist brks <- readIModBreaks hug ibi - return $ bi_tick_mod $ getBreakSourceId ibi brks + return $ getBreakSourceMod ibi brks getHistorySpan :: HUG.HomeUnitGraph -> History -> IO SrcSpan getHistorySpan hug hist = do ===================================== compiler/GHC/StgToByteCode.hs ===================================== @@ -63,7 +63,7 @@ import GHC.StgToCmm.Closure ( NonVoid(..), fromNonVoid, idPrimRepU, assertNonVoidIds, assertNonVoidStgArgs ) import GHC.StgToCmm.Layout import GHC.Runtime.Heap.Layout hiding (WordOff, ByteOff, wordsToBytes) -import GHC.Runtime.Interpreter ( interpreterProfiled ) +import GHC.Runtime.Interpreter ( interpreterProfiled, readIModModBreaks ) import GHC.Data.Bitmap import GHC.Data.FlatBag as FlatBag import GHC.Data.OrdList @@ -99,6 +99,7 @@ import GHC.CoreToIface import Control.Monad.IO.Class import Control.Monad.Trans.Reader (ReaderT(..)) import Control.Monad.Trans.State (StateT(..)) +import Data.Array ((!)) -- ----------------------------------------------------------------------------- -- Generating byte code for a complete module @@ -393,26 +394,26 @@ schemeR_wrk fvs nm original_body (args, body) -- | Introduce break instructions for ticked expressions. -- If no breakpoint information is available, the instruction is omitted. schemeER_wrk :: StackDepth -> BCEnv -> CgStgExpr -> BcM BCInstrList -schemeER_wrk d p (StgTick (Breakpoint tick_ty tick_id fvs) rhs) = do - code <- schemeE d 0 p rhs - mb_current_mod_breaks <- getCurrentModBreaks - case mb_current_mod_breaks of - -- if we're not generating ModBreaks for this module for some reason, we - -- can't store breakpoint occurrence information. - Nothing -> pure code - Just current_mod_breaks -> do - platform <- profilePlatform <$> getProfile - let idOffSets = getVarOffSets platform d p fvs - ty_vars = tyCoVarsOfTypesWellScoped (tick_ty:map idType fvs) - toWord :: Maybe (Id, WordOff) -> Maybe (Id, Word) - toWord = fmap (\(i, wo) -> (i, fromIntegral wo)) - breakInfo = dehydrateCgBreakInfo ty_vars (map toWord idOffSets) tick_ty tick_id +schemeER_wrk d p (StgTick bp@(Breakpoint tick_ty tick_id fvs) rhs) = do + platform <- profilePlatform <$> getProfile + + -- When we find a tick we update the "last breakpoint location". + -- We use it when constructing step-out BRK_FUNs in doCase + -- See Note [Debugger: Stepout internal break locs] + code <- withBreakTick bp $ schemeE d 0 p rhs + + let idOffSets = getVarOffSets platform d p fvs + ty_vars = tyCoVarsOfTypesWellScoped (tick_ty:map idType fvs) + toWord :: Maybe (Id, WordOff) -> Maybe (Id, Word) + toWord = fmap (\(i, wo) -> (i, fromIntegral wo)) + breakInfo = dehydrateCgBreakInfo ty_vars (map toWord idOffSets) tick_ty (Right tick_id) - let info_mod = modBreaks_module current_mod_breaks - infox <- newBreakInfo breakInfo + mibi <- newBreakInfo breakInfo + + return $ case mibi of + Nothing -> code + Just ibi -> BRK_FUN ibi `consOL` code - let breakInstr = BRK_FUN (InternalBreakpointId info_mod infox) - return $ breakInstr `consOL` code schemeER_wrk d p rhs = schemeE d 0 p rhs getVarOffSets :: Platform -> StackDepth -> BCEnv -> [Id] -> [Maybe (Id, WordOff)] @@ -1325,19 +1326,35 @@ doCase d s p scrut bndr alts | ubx_tuple_frame = SLIDE 0 3 `consOL` alt_final1 | otherwise = SLIDE 0 1 `consOL` alt_final1 - -- When entering a case continuation BCO, the stack is always headed - -- by the stg_ret frame and the stg_ctoi frame that returned to it. - -- See Note [Stack layout when entering run_BCO] - -- - -- Right after the breakpoint instruction, a case continuation BCO - -- drops the stg_ret and stg_ctoi frame headers (see alt_final1, - -- alt_final2), leaving the stack with the scrutinee followed by the - -- free variables (with depth==d_bndr) - alt_final - | gopt Opt_InsertBreakpoints (hsc_dflags hsc_env) - -- See Note [Debugger: BRK_ALTS] - = BRK_ALTS False `consOL` alt_final2 - | otherwise = alt_final2 + -- When entering a case continuation BCO, the stack is always headed + -- by the stg_ret frame and the stg_ctoi frame that returned to it. + -- See Note [Stack layout when entering run_BCO] + -- + -- Right after the breakpoint instruction, a case continuation BCO + -- drops the stg_ret and stg_ctoi frame headers (see alt_final1, + -- alt_final2), leaving the stack with the scrutinee followed by the + -- free variables (with depth==d_bndr) + alt_final <- getLastBreakTick >>= \case + Just (Breakpoint tick_ty tick_id fvs) + | gopt Opt_InsertBreakpoints (hsc_dflags hsc_env) + -- Construct an internal breakpoint to put at the start of this case + -- continuation BCO, for step-out. + -- See Note [Debugger: Stepout internal break locs] + -> do + internal_tick_loc <- makeCaseInternalBreakLoc tick_id + + -- same fvs available in the case expression are available in the case continuation + let idOffSets = getVarOffSets platform d p fvs + ty_vars = tyCoVarsOfTypesWellScoped (tick_ty:map idType fvs) + toWord :: Maybe (Id, WordOff) -> Maybe (Id, Word) + toWord = fmap (\(i, wo) -> (i, fromIntegral wo)) + breakInfo = dehydrateCgBreakInfo ty_vars (map toWord idOffSets) tick_ty (Left internal_tick_loc) + + mibi <- newBreakInfo breakInfo + return $ case mibi of + Nothing -> alt_final2 + Just ibi -> BRK_FUN ibi `consOL` alt_final2 + _ -> pure alt_final2 add_bco_name <- shouldAddBcoName let @@ -1357,72 +1374,122 @@ doCase d s p scrut bndr alts _ -> panic "schemeE(StgCase).push_alts" in return (PUSH_ALTS alt_bco scrut_rep `consOL` scrut_code) +-- | Come up with an 'InternalBreakLoc' from the location of the given 'BreakpointId'. +-- See also Note [Debugger: Stepout internal break locs] +makeCaseInternalBreakLoc :: BreakpointId -> BcM InternalBreakLoc +makeCaseInternalBreakLoc bid = do + hug <- hsc_HUG <$> getHscEnv + curr_mod <- getCurrentModule + mb_mod_brks <- getCurrentModBreaks + + InternalBreakLoc <$> case bid of + BreakpointId{bi_tick_mod, bi_tick_index} + | bi_tick_mod == curr_mod + , Just these_mbs <- mb_mod_brks + -> do + return $ modBreaks_locs these_mbs ! bi_tick_index + | otherwise + -> do + other_mbs <- liftIO $ readIModModBreaks hug bi_tick_mod + return $ modBreaks_locs other_mbs ! bi_tick_index + {- -Note [Debugger: BRK_ALTS] -~~~~~~~~~~~~~~~~~~~~~~~~~ -As described in Note [Debugger: Step-out] in rts/Interpreter.c, to implement -the stepping-out debugger feature we traverse the stack at runtime, identify -the first continuation BCO, and explicitly enable that BCO's breakpoint thus -ensuring that we stop exactly when we return to the continuation. - -However, case continuation BCOs (produced by PUSH_ALTS and which merely compute -which case alternative BCO to enter next) contain no user-facing breakpoint -ticks (BRK_FUN). While we could in principle add breakpoints in case continuation -BCOs, there are a few reasons why this is not an attractive option: - - 1) It's not useful to a user stepping through the program to always have a - breakpoint after the scrutinee is evaluated but before the case alternative - is selected. The source span associated with such a breakpoint would also be - slightly awkward to choose. - - 2) It's not easy to add a breakpoint tick before the case alternatives because in - essentially all internal representations they are given as a list of Alts - rather than an expression. - -To provide the debugger a way to break in a case continuation -despite the BCOs' lack of BRK_FUNs, we introduce an alternative -type of breakpoint, represented by the BRK_ALTS instruction, -at the start of every case continuation BCO. For instance, - - case x of - 0# -> ... - _ -> ... - -will produce a continuation of the form (N.B. the below bytecode -is simplified): - - PUSH_ALTS P - BRK_ALTS 0 - TESTEQ_I 0 lblA - PUSH_BCO - BRK_FUN 0 - -- body of 0# alternative - ENTER - - lblA: - PUSH_BCO - BRK_FUN 1 - -- body of wildcard alternative - ENTER - -When enabled (by its single boolean operand), the BRK_ALTS instruction causes -the program to break at the next encountered breakpoint (implemented -by setting the TSO's TSO_STOP_NEXT_BREAKPOINT flag). Since the case -continuation BCO will ultimately jump to one of the alternatives (each of -which having its own BRK_FUN) we are guaranteed to stop in the taken alternative. - -It's important that BRK_ALTS (just like BRK_FUN) is the first instruction of -the BCO, since that's where the debugger will look to enable it at runtime. - -KNOWN ISSUES: -------------- -This implementation of BRK_ALTS that modifies the first argument of the -bytecode to enable it does not allow multi-threaded debugging because the BCO -object is shared across threads and enabling the breakpoint in one will enable -it in all other threads too. This will have to change to support multi-threads -debugging. - -The progress towards multi-threaded debugging is tracked by #26064 +Note [Debugger: Stepout internal break locs] +~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ +Step-out tells the interpreter to run until the current function +returns to where it was called from, and stop there. + +This is achieved by enabling the BRK_FUN found on the first RET_BCO +frame on the stack (See [Note Debugger: Step-out]). + +Case continuation BCOs (which select an alternative branch) must +therefore be headed by a BRK_FUN. An example: + + f x = case g x of <--- end up here + 1 -> ... + 2 -> ... + + g y = ... <--- step out from here + +- `g` will return a value to the case continuation BCO in `f` +- The case continuation BCO will receive the value returned from g +- Match on it and push the alternative continuation for that branch +- And then enter that alternative. + +If we step-out of `g`, the first RET_BCO on the stack is the case +continuation of `f` -- execution should stop at its start, before +selecting an alternative. (One might ask, "why not enable the breakpoint +in the alternative instead?", because the alternative continuation is +only pushed to the stack *after* it is selected by the case cont. BCO) + +However, the case cont. BCO is not associated with any source-level +tick, it is merely the glue code which selects alternatives which do +have source level ticks. Therefore, we have to come up at code +generation time with a breakpoint location ('InternalBreakLoc') to +display to the user when it is stopped there. + +Our solution is to use the last tick seen just before reaching the case +continuation. This is robust because a case continuation will thus +always have a relevant breakpoint location: + + - The source location will be the last source-relevant expression + executed before the continuation is pushed + + - So the source location will point to the thing you've just stepped + out of + + - Doing :step-local from there will put you on the selected + alternative (which at the source level may also be the e.g. next + line in a do-block) + +Examples, using angle brackets (<<...>>) to denote the breakpoint span: + + f x = case <<g x>> {- step in here -} of + 1 -> ... + 2 -> ...> + + g y = <<...>> <--- step out from here + + ... + + f x = <<case g x of <--- end up here, whole case highlighted + 1 -> ... + 2 -> ...>> + + doing :step-local ... + + f x = case g x of + 1 -> <<...>> <--- stop in the alternative + 2 -> ... + +A second example based on T26042d2, where the source is a do-block IO +action, optimised to a chain of `case expressions`. + + main = do + putStrLn "hello1" + <<f>> <--- step-in here + putStrLn "hello3" + putStrLn "hello4" + + f = do + <<putStrLn "hello2.1">> <--- step-out from here + putStrLn "hello2.2" + + ... + + main = do + putStrLn "hello1" + <<f>> <--- end up here again, the previously executed expression + putStrLn "hello3" + putStrLn "hello4" + + doing step/step-local ... + + main = do + putStrLn "hello1" + f + <<putStrLn "hello3">> <--- straight to the next line + putStrLn "hello4" -} -- ----------------------------------------------------------------------------- @@ -2625,6 +2692,7 @@ data BcM_Env { bcm_hsc_env :: !HscEnv , bcm_module :: !Module -- current module (for breakpoints) , modBreaks :: !(Maybe ModBreaks) + , last_bp_tick :: !(Maybe StgTickish) } data BcM_State @@ -2643,7 +2711,7 @@ newtype BcM r = BcM (BcM_Env -> BcM_State -> IO (r, BcM_State)) runBc :: HscEnv -> Module -> Maybe ModBreaks -> BcM r -> IO (r, BcM_State) runBc hsc_env this_mod mbs (BcM m) - = m (BcM_Env hsc_env this_mod mbs) (BcM_State 0 0 IntMap.empty) + = m (BcM_Env hsc_env this_mod mbs Nothing) (BcM_State 0 0 IntMap.empty) instance HasDynFlags BcM where getDynFlags = hsc_dflags <$> getHscEnv @@ -2673,14 +2741,19 @@ getLabelsBc n = BcM $ \_ st -> let ctr = nextlabel st in return (coerce [ctr .. ctr+n-1], st{nextlabel = ctr+n}) -newBreakInfo :: CgBreakInfo -> BcM Int -newBreakInfo info = BcM $ \_ st -> - let ix = breakInfoIdx st - st' = st - { breakInfo = IntMap.insert ix info (breakInfo st) - , breakInfoIdx = ix + 1 - } - in return (ix, st') +newBreakInfo :: CgBreakInfo -> BcM (Maybe InternalBreakpointId) +newBreakInfo info = BcM $ \env st -> do + -- if we're not generating ModBreaks for this module for some reason, we + -- can't store breakpoint occurrence information. + case modBreaks env of + Nothing -> pure (Nothing, st) + Just modBreaks -> do + let ix = breakInfoIdx st + st' = st + { breakInfo = IntMap.insert ix info (breakInfo st) + , breakInfoIdx = ix + 1 + } + return (Just $ InternalBreakpointId (modBreaks_module modBreaks) ix, st') getCurrentModule :: BcM Module getCurrentModule = BcM $ \env st -> return (bcm_module env, st) @@ -2688,12 +2761,20 @@ getCurrentModule = BcM $ \env st -> return (bcm_module env, st) getCurrentModBreaks :: BcM (Maybe ModBreaks) getCurrentModBreaks = BcM $ \env st -> return (modBreaks env, st) +withBreakTick :: StgTickish -> BcM a -> BcM a +withBreakTick bp (BcM act) = BcM $ \env st -> + act env{last_bp_tick=Just bp} st + +getLastBreakTick :: BcM (Maybe StgTickish) +getLastBreakTick = BcM $ \env st -> + pure (last_bp_tick env, st) + tickFS :: FastString tickFS = fsLit "ticked" -- Dehydrating CgBreakInfo -dehydrateCgBreakInfo :: [TyVar] -> [Maybe (Id, Word)] -> Type -> BreakpointId -> CgBreakInfo +dehydrateCgBreakInfo :: [TyVar] -> [Maybe (Id, Word)] -> Type -> Either InternalBreakLoc BreakpointId -> CgBreakInfo dehydrateCgBreakInfo ty_vars idOffSets tick_ty bid = CgBreakInfo { cgb_tyvars = map toIfaceTvBndr ty_vars ===================================== ghc/GHCi/UI.hs ===================================== @@ -45,7 +45,7 @@ import GHC.Runtime.Eval (mkTopLevEnv) import GHC.Runtime.Eval.Utils -- The GHC interface -import GHC.ByteCode.Breakpoints (imodBreaks_modBreaks, InternalBreakpointId(..), getBreakSourceId) +import GHC.ByteCode.Breakpoints (imodBreaks_modBreaks, InternalBreakpointId(..), getBreakSourceId, getBreakSourceMod) import GHC.Runtime.Interpreter import GHCi.RemoteTypes import GHCi.BreakArray( breakOn, breakOff ) @@ -1621,7 +1621,7 @@ toBreakIdAndLocation (Just inf) = do brks <- liftIO $ readIModBreaks hug inf let bi = getBreakSourceId inf brks return $ listToMaybe [ id_loc | id_loc@(_,loc) <- IntMap.assocs (breaks st), - breakId loc == bi ] + Right (breakId loc) == bi ] printStoppedAtBreakInfo :: GHC.GhcMonad m => Resume -> [Name] -> m () printStoppedAtBreakInfo res names = do @@ -3825,7 +3825,7 @@ pprStopped res = do hug <- hsc_HUG <$> GHC.getSession brks <- liftIO $ readIModBreaks hug ibi return $ Just $ moduleName $ - bi_tick_mod $ getBreakSourceId ibi brks + getBreakSourceMod ibi brks return $ text "Stopped in" <+> ((case mb_mod_name of ===================================== rts/Disassembler.c ===================================== @@ -101,9 +101,6 @@ disInstr ( StgBCO *bco, int pc ) } debugBelch("\n"); break; } - case bci_BRK_ALTS: - debugBelch ("BRK_ALTS %d\n", BCO_NEXT); - break; case bci_SWIZZLE: { W_ stkoff = BCO_GET_LARGE_ARG; StgInt by = BCO_GET_LARGE_ARG; ===================================== rts/Interpreter.c ===================================== @@ -370,16 +370,11 @@ to the continuation. To achieve this, when the flag is set as the interpreter is re-entered: (1) Traverse the stack until a RET_BCO frame is found or we otherwise hit the bottom (STOP_FRAME). - (2) Look for a breakpoint instruction heading the BCO instructions (a + (2) Look for a BRK_FUN instruction heading the BCO instructions (a breakpoint, when present, is always the first instruction in a BCO) - (2a) For PUSH_ALT BCOs, the breakpoint instruction will be BRK_ALTS - (as explained in Note [Debugger: BRK_ALTS]) and it can be enabled by - setting its first operand to 1. - - (2b) Otherwise, the instruction will be BRK_FUN and the breakpoint can be - enabled by setting the associated BreakArray at the associated tick - index to 0. + The breakpoint can be enabled by setting the associated BreakArray at the + associated internal breakpoint index to 0. By simply enabling the breakpoint heading the continuation we can ensure that when it is returned to we will stop there without additional work -- it @@ -740,8 +735,8 @@ interpretBCO (Capability* cap) int bciPtr = 0; StgWord16 bci = BCO_NEXT; - /* A breakpoint instruction (BRK_FUN or BRK_ALTS) is always the first - * instruction in a BCO */ + /* A breakpoint instruction (BRK_FUN) can only be the first instruction + * in a BCO */ if ((bci & 0xFF) == bci_BRK_FUN) { W_ arg1_brk_array, arg4_info_index; @@ -756,10 +751,6 @@ interpretBCO (Capability* cap) // ACTIVATE the breakpoint by tick index ((StgInt*)breakPoints->payload)[arg4_info_index] = 0; } - else if ((bci & 0xFF) == bci_BRK_ALTS) { - // ACTIVATE BRK_ALTS by setting its only argument to ON - instrs[1] = 1; - } // else: if there is no BRK instruction perhaps we should keep // traversing; that said, the continuation should always have a BRK } @@ -1804,17 +1795,6 @@ run_BCO: goto nextInsn; } - /* See Note [Debugger: BRK_ALTS] */ - case bci_BRK_ALTS: - { - StgWord16 active = BCO_NEXT; - if (active) { - cap->r.rCurrentTSO->flags |= TSO_STOP_NEXT_BREAKPOINT; - } - - goto nextInsn; - } - case bci_STKCHECK: { // Explicit stack check at the beginning of a function // *only* (stack checks in case alternatives are ===================================== rts/include/rts/Bytecodes.h ===================================== @@ -214,8 +214,6 @@ #define bci_OP_INDEX_ADDR_32 242 #define bci_OP_INDEX_ADDR_64 243 -#define bci_BRK_ALTS 244 - /* If you need to go past 255 then you will run into the flags */ ===================================== testsuite/tests/ghci.debugger/scripts/T26042b.stdout ===================================== @@ -8,35 +8,32 @@ _result :: 10 foo True i = return i ^^^^^^^^ 11 foo False _ = do -Stopped in Main.bar, T26042b.hs:21:3-10 +Stopped in Main., T26042b.hs:20:3-17 _result :: GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld, Int #) = _ -y :: Int = _ +19 let t = z * 2 20 y <- foo True t + ^^^^^^^^^^^^^^^ 21 return y - ^^^^^^^^ -22 -Stopped in Main.foo, T26042b.hs:15:3-10 +Stopped in Main., T26042b.hs:14:3-18 _result :: GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld, Int #) = _ -n :: Int = _ +13 y = 4 14 n <- bar (x + y) + ^^^^^^^^^^^^^^^^ 15 return n - ^^^^^^^^ -16 -Stopped in Main.main, T26042b.hs:6:3-9 +Stopped in Main., T26042b.hs:5:3-26 _result :: GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld, () #) = _ -a :: Int = _ +4 main = do 5 a <- foo False undefined + ^^^^^^^^^^^^^^^^^^^^^^^^ 6 print a - ^^^^^^^ -7 print a 14 14 ===================================== testsuite/tests/ghci.debugger/scripts/T26042c.script ===================================== @@ -14,15 +14,7 @@ main -- we go straight to `main`. :stepout :list --- stepping out from here will stop in the thunk (TODO: WHY?) -:stepout -:list - --- bring us back to main from the thunk (why were we stopped there?...) -:stepout -:list - --- and finally out +-- stepping out from here will exit main :stepout -- this test is also run with optimisation to make sure the IO bindings inline and we can stop at them ===================================== testsuite/tests/ghci.debugger/scripts/T26042c.stdout ===================================== @@ -8,17 +8,14 @@ _result :: 10 foo True i = return i ^^^^^^^^ 11 foo False _ = do -Stopped in Main.main, T26042c.hs:6:3-9 +Stopped in Main., T26042c.hs:5:3-26 _result :: GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld, () #) = _ -a :: Int = _ +4 main = do 5 a <- foo False undefined + ^^^^^^^^^^^^^^^^^^^^^^^^ 6 print a - ^^^^^^^ -7 print a 14 14 -not stopped at a breakpoint -not stopped at a breakpoint ===================================== testsuite/tests/ghci.debugger/scripts/T26042d2.hs ===================================== @@ -0,0 +1,13 @@ + +module Main where + +main = do + putStrLn "hello1" + f + putStrLn "hello3" + putStrLn "hello4" + +f = do + putStrLn "hello2.1" + putStrLn "hello2.2" +{-# NOINLINE f #-} ===================================== testsuite/tests/ghci.debugger/scripts/T26042d2.script ===================================== @@ -0,0 +1,12 @@ +:load T26042d2.hs + +:break 11 +main +:list +:stepout +:list +:stepout + +-- should exit! we compile this test case with -O1 to make sure the monad >> are inlined +-- and thus the test relies on the filtering behavior based on SrcSpans for stepout + ===================================== testsuite/tests/ghci.debugger/scripts/T26042d2.stdout ===================================== @@ -0,0 +1,24 @@ +Breakpoint 0 activated at T26042d2.hs:11:3-21 +hello1 +Stopped in Main.f, T26042d2.hs:11:3-21 +_result :: + GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld + -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld, + () #) = _ +10 f = do +11 putStrLn "hello2.1" + ^^^^^^^^^^^^^^^^^^^ +12 putStrLn "hello2.2" +hello2.1 +hello2.2 +Stopped in Main., T26042d2.hs:6:3 +_result :: + GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld + -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld, + () #) = _ +5 putStrLn "hello1" +6 f + ^ +7 putStrLn "hello3" +hello3 +hello4 ===================================== testsuite/tests/ghci.debugger/scripts/T26042e.stdout ===================================== @@ -7,14 +7,12 @@ y :: [a1] -> Int = _ 11 let !z = y x ^^^^^^^^^^^^ 12 let !t = y ['b'] -Stopped in T7.main, T26042e.hs:19:3-11 +Stopped in T7., T26042e.hs:18:3-17 _result :: IO () = _ -x :: Int = _ -y :: Int = _ +17 main = do 18 let !(x, y) = a + ^^^^^^^^^^^^^^^ 19 print '1' - ^^^^^^^^^ -20 print '2' '1' '2' '3' ===================================== testsuite/tests/ghci.debugger/scripts/T26042f2.stdout ===================================== @@ -8,18 +8,16 @@ x :: Int = 450 21 pure (x + 3) ^^ 22 {-# OPAQUE t #-} -Stopped in T8.g, T26042f.hs:15:3-17 +Stopped in T8., T26042f.hs:14:3-14 _result :: Identity Int = _ -a :: Int = 453 +13 g x = do 14 a <- t (x*2) + ^^^^^^^^^^^^ 15 n <- pure (a+a) - ^^^^^^^^^^^^^^^ -16 return (n+n) -Stopped in T8.f, T26042f.hs:9:3-17 +Stopped in T8., T26042f.hs:8:3-14 _result :: Identity Int = _ -b :: Int = 1812 +7 f x = do 8 b <- g (x*x) + ^^^^^^^^^^^^ 9 y <- pure (b+b) - ^^^^^^^^^^^^^^^ -10 return (y+y) 7248 ===================================== testsuite/tests/ghci.debugger/scripts/T26042g.stdout ===================================== @@ -6,10 +6,13 @@ x :: Int = 14 11 succ x = (-) (x - 2) (x + 1) ^^^^^^^^^^^^^^^^^^^ 12 -Stopped in T9.top, T26042g.hs:8:10-21 +Stopped in T9., T26042g.hs:(6,3)-(8,21) _result :: Int = _ +5 top = do + vv +6 case succ 14 of 7 5 -> 5 8 _ -> 6 + other 55 - ^^^^^^^^^^^^ + ^^ 9 171 ===================================== testsuite/tests/ghci.debugger/scripts/all.T ===================================== @@ -147,8 +147,9 @@ test('T25932', extra_files(['T25932.hs']), ghci_script, ['T25932.script']) # Step out tests test('T26042b', [extra_hc_opts('-O -fno-unoptimized-core-for-interpreter'), extra_files(['T26042b.hs'])], ghci_script, ['T26042b.script']) -test('T26042c', [expect_broken(26042),extra_hc_opts('-O -fno-unoptimized-core-for-interpreter'), extra_files(['T26042c.hs'])], ghci_script, ['T26042c.script']) +test('T26042c', [extra_hc_opts('-O -fno-unoptimized-core-for-interpreter'), extra_files(['T26042c.hs'])], ghci_script, ['T26042c.script']) test('T26042d', [extra_hc_opts('-O -fno-unoptimized-core-for-interpreter'), extra_files(['T26042d.hs'])], ghci_script, ['T26042d.script']) +test('T26042d2', [extra_hc_opts('-O -fno-unoptimized-core-for-interpreter'), extra_files(['T26042d2.hs'])], ghci_script, ['T26042d2.script']) test('T26042e', extra_files(['T26042e.hs']), ghci_script, ['T26042e.script']) test('T26042f1', extra_files(['T26042f.hs', 'T26042f.script']), ghci_script, ['T26042f.script']) # >> is not inlined, so stepout has nowhere to stop test('T26042f2', [extra_hc_opts('-O -fno-unoptimized-core-for-interpreter'), extra_files(['T26042f.hs', 'T26042f.script'])], ghci_script, ['T26042f.script']) View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/21f1d8c3bfe075fdc1d110b0c94106be... -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/commit/21f1d8c3bfe075fdc1d110b0c94106be... You're receiving this email because of your account on gitlab.haskell.org.