Rodrigo Mesquita pushed to branch wip/romes/step-out-11 at Glasgow Haskell Compiler / GHC Commits: 6a4011a3 by Rodrigo Mesquita at 2025-07-28T16:21:32+01:00 debugger: Allow BRK_FUNs to head case continuation BCOs When we start executing a BCO, we may want to yield to the scheduler: this may be triggered by a heap/stack check, context switch, or a breakpoint. To yield, we need to put the stack in a state such that when execution is resumed we are back to where we yielded from. Previously, a BKR_FUN could only head a function BCO because we only knew how to construct a valid stack for yielding from one -- simply add `apply_interp_info` + the BCO to resume executing. This is valid because the stack at the start of run_BCO is headed by that BCO's arguments. However, in case continuation BCOs (as per Note [Case continuation BCOs]), we couldn't easily reconstruct a valid stack that could be resumed because we dropped too soon the stack frames regarding the value returned (stg_ret) and received (stg_ctoi) by that continuation. This is especially tricky because of the variable type and size return frames (e.g. pointer ret_p/ctoi_R1p vs a tuple ret_t/ctoi_t2). The trick to being able to yield from a BRK_FUN at the start of a case cont BCO is to stop removing the ret frame headers eagerly and instead keep them until the BCO starts executing. The new layout at the start of a case cont. BCO is described by the new Note [Stack layout when entering run_BCO]. Now, we keep the ret_* and ctoi_* frames when entering run_BCO. A BRK_FUN is then executed if found, and the stack is yielded as-is with the preserved ret and ctoi frames. Then, a case cont BCO's instructions always SLIDE off the headers of the ret and ctoi frames, in StgToByteCode.doCase, turning a stack like | .... | +---------------+ | fv2 | +---------------+ | fv1 | +---------------+ | BCO | +---------------+ | stg_ctoi_ret_ | +---------------+ | retval | +---------------+ | stg_ret_..... | +---------------+ into | .... | +---------------+ | fv2 | +---------------+ | fv1 | +---------------+ | retval | +---------------+ for the remainder of the BCO. Moreover, this more uniform approach of keeping the ret and ctoi frames means we need less ad-hoc logic concerning the variable size of ret_tuple vs ret_p/np frames in the code generator and interpreter: Always keep the return to cont. stack intact at the start of run_BCO, and the statically generated instructions will take care of adjusting it. Unlocks BRK_FUNs at the start of case cont. BCOs which will enable a better user-facing step-out (#26042) which is free of the bugs the current BRK_ALTS implementation suffers from (namely, using BRK_FUN rather than BRK_ALTS in a case cont. means we'll never accidentally end up in a breakpoint "deeper" than the continuation, because we stop at the case cont itself rather than on the first breakpoint we evaluate after it). - - - - - 5047e932 by Rodrigo Mesquita at 2025-07-28T16:21:32+01:00 Add InternalBreakLocs for code-generation time Brk locations T26042d2 is a simple example displaying how this approach is not good enough e.g. for do blocks because the cases continuations currently end up not surrounded by a tick. TODO: Figure out how to add BRK_FUNs to all case continuations where it is relevant that we can step out to TODO: Test step-out from a continuation which receives an unboxed tuple as an argument - - - - - 13 changed files: - compiler/GHC/ByteCode/Breakpoints.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 - libraries/ghci/GHCi/Run.hs - rts/Interpreter.c - + 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/T26042g.stdout - testsuite/tests/ghci.debugger/scripts/all.T Changes: ===================================== 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,19 @@ 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 [Internal Breakpoint Locations] } -- 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. +-- See Note [Internal Breakpoint Locations] +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 +208,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 +249,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 +268,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/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,30 @@ 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 - - let info_mod = modBreaks_module current_mod_breaks - infox <- newBreakInfo breakInfo +schemeER_wrk d p (StgTick bp@(Breakpoint tick_ty tick_id fvs) rhs) = do + platform <- profilePlatform <$> getProfile + + code <- case rhs of + -- When we find a tick surrounding a case expression we introduce a new BRK_FUN + -- instruction at the start of the case *continuation*, in addition to the + -- usual BRK_FUN surrounding the StgCase) + -- See Note [TODO] + StgCase scrut bndr _ alts + -> doCase d 0 p (Just bp) scrut bndr alts + _ -> 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) + + 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)] @@ -614,7 +619,7 @@ schemeE d s p (StgTick _ rhs) = schemeE d s p rhs schemeE d s p (StgCase scrut _ _ []) = schemeE d s p scrut schemeE d s p (StgCase scrut bndr _ alts) - = doCase d s p scrut bndr alts + = doCase d s p Nothing scrut bndr alts {- @@ -1106,11 +1111,15 @@ doCase :: StackDepth -> Sequel -> BCEnv + -> Maybe StgTickish + -- ^ The breakpoint surrounding the full case expression, if any (only + -- source-level cases get breakpoint ticks, and those are the only we care + -- about). See Note [TODO] -> CgStgExpr -> Id -> [CgStgAlt] -> BcM BCInstrList -doCase d s p scrut bndr alts +doCase d s p m_bid scrut bndr alts = do profile <- getProfile hsc_env <- getHscEnv @@ -1140,43 +1149,34 @@ doCase d s p scrut bndr alts -- When an alt is entered, it assumes the returned value is -- on top of the itbl; see Note [Return convention for non-tuple values] -- for details. - ret_frame_size_b :: StackDepth - ret_frame_size_b | ubx_tuple_frame = - (if profiling then 5 else 4) * wordSize platform - | otherwise = 2 * wordSize platform + ret_frame_size_w :: WordOff + ret_frame_size_w | ubx_tuple_frame = + if profiling then 5 else 4 + | otherwise = 2 -- The stack space used to save/restore the CCCS when profiling save_ccs_size_b | profiling && not ubx_tuple_frame = 2 * wordSize platform | otherwise = 0 - -- The size of the return frame info table pointer if one exists - unlifted_itbl_size_b :: StackDepth - unlifted_itbl_size_b | ubx_tuple_frame = wordSize platform - | otherwise = 0 - (bndr_size, call_info, args_offsets) | ubx_tuple_frame = let bndr_reps = typePrimRep (idType bndr) (call_info, args_offsets) = layoutNativeCall profile NativeTupleReturn 0 id bndr_reps - in ( wordsToBytes platform (nativeCallSize call_info) + in ( nativeCallSize call_info , call_info , args_offsets ) - | otherwise = ( wordsToBytes platform (idSizeW platform bndr) + | otherwise = ( idSizeW platform bndr , voidTupleReturnInfo , [] ) - -- depth of stack after the return value has been pushed + -- Depth of stack after the return value has been pushed + -- This is the stack depth at the continuation. d_bndr = - d + ret_frame_size_b + bndr_size - - -- depth of stack after the extra info table for an unlifted return - -- has been pushed, if any. This is the stack depth at the - -- continuation. - d_alts = d + ret_frame_size_b + bndr_size + unlifted_itbl_size_b + d + wordsToBytes platform bndr_size -- Env in which to compile the alts, not including -- any vars bound by the alts themselves @@ -1188,13 +1188,13 @@ doCase d s p scrut bndr alts -- given an alt, return a discr and code for it. codeAlt :: CgStgAlt -> BcM (Discr, BCInstrList) codeAlt GenStgAlt{alt_con=DEFAULT,alt_bndrs=_,alt_rhs=rhs} - = do rhs_code <- schemeE d_alts s p_alts rhs + = do rhs_code <- schemeE d_bndr s p_alts rhs return (NoDiscr, rhs_code) codeAlt alt@GenStgAlt{alt_con=_, alt_bndrs=bndrs, alt_rhs=rhs} -- primitive or nullary constructor alt: no need to UNPACK | null real_bndrs = do - rhs_code <- schemeE d_alts s p_alts rhs + rhs_code <- schemeE d_bndr s p_alts rhs return (my_discr alt, rhs_code) | isUnboxedTupleType bndr_ty || isUnboxedSumType bndr_ty = let bndr_ty = idPrimRepU . fromNonVoid @@ -1206,7 +1206,7 @@ doCase d s p scrut bndr alts bndr_ty (assertNonVoidIds bndrs) - stack_bot = d_alts + stack_bot = d_bndr p' = Map.insertList [ (arg, tuple_start - @@ -1224,7 +1224,7 @@ doCase d s p scrut bndr alts (addIdReps (assertNonVoidIds real_bndrs)) size = WordOff tot_wds - stack_bot = d_alts + wordsToBytes platform size + stack_bot = d_bndr + wordsToBytes platform size -- convert offsets from Sp into offsets into the virtual stack p' = Map.insertList @@ -1324,22 +1324,53 @@ doCase d s p scrut bndr alts alt_stuff <- mapM codeAlt alts alt_final0 <- mkMultiBranch maybe_ncons alt_stuff - let alt_final1 - | ubx_tuple_frame = SLIDE 0 2 `consOL` alt_final0 - | otherwise = alt_final0 - alt_final - | gopt Opt_InsertBreakpoints (hsc_dflags hsc_env) - -- See Note [Debugger: BRK_ALTS] - = BRK_ALTS False `consOL` alt_final1 - | otherwise = alt_final1 + let + + -- drop the stg_ctoi_*_info header... + alt_final1 = SLIDE bndr_size ret_frame_size_w `consOL` alt_final0 + + -- after dropping the stg_ret_*_info header + alt_final2 + | 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 <- case m_bid of + 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. + -- See Note [TODO] + -> 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 alt_bco_name = getName bndr alt_bco = mkProtoBCO platform add_bco_name alt_bco_name alt_final (Left alts) 0{-no arity-} bitmap_size bitmap True{-is alts-} - scrut_code <- schemeE (d + ret_frame_size_b + save_ccs_size_b) - (d + ret_frame_size_b + save_ccs_size_b) + scrut_code <- schemeE (d + wordsToBytes platform ret_frame_size_w + save_ccs_size_b) + (d + wordsToBytes platform ret_frame_size_w + save_ccs_size_b) p scrut if ubx_tuple_frame then do let tuple_bco = tupleBCO platform call_info args_offsets @@ -1351,6 +1382,24 @@ doCase d s p scrut bndr alts _ -> panic "schemeE(StgCase).push_alts" in return (PUSH_ALTS alt_bco scrut_rep `consOL` scrut_code) +makeCaseInternalBreakLoc :: BreakpointId -> BcM InternalBreakLoc +makeCaseInternalBreakLoc bid = do + hug <- hsc_HUG <$> getHscEnv + curr_mod <- getCurrentModule + mb_mod_brks <- getCurrentModBreaks + + -- TODO: Subtract the scrutinee loc from the case loc to get continuation loc + 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] ~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -2667,14 +2716,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) @@ -2687,7 +2741,7 @@ 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 ===================================== libraries/ghci/GHCi/Run.hs ===================================== @@ -362,6 +362,14 @@ withBreakAction opts breakMVar statusMVar mtid act info_mod_uid <- BS.packCString (Ptr info_mod_uid#) pure (Just (EvalBreakpoint info_mod info_mod_uid (I# infox#))) putMVar statusMVar $ EvalBreak apStack_r breakpoint resume_r ccs + + -- Block until this thread is resumed (by the thread which took the + -- `ResumeContext` from the `statusMVar`). + -- + -- The `onBreak` function must have been called from `rts/Interpreter.c` + -- when interpreting a `BRK_FUN`. After taking from the MVar, the function + -- returns to the continuation on the stack which is where the interpreter + -- was stopped. takeMVar breakMVar resetBreakAction stablePtr = do ===================================== rts/Interpreter.c ===================================== @@ -284,6 +284,18 @@ allocate_NONUPD (Capability *cap, int n_words) return allocate(cap, stg_max(sizeofW(StgHeader)+MIN_PAYLOAD_SIZE, n_words)); } +STATIC_INLINE int +is_ctoi_nontuple_frame(const StgPtr frame_head) { + return ( + (W_)frame_head == (W_)&stg_ctoi_R1p_info || + (W_)frame_head == (W_)&stg_ctoi_R1n_info || + (W_)frame_head == (W_)&stg_ctoi_F1_info || + (W_)frame_head == (W_)&stg_ctoi_D1_info || + (W_)frame_head == (W_)&stg_ctoi_L1_info || + (W_)frame_head == (W_)&stg_ctoi_V_info + ); +} + int rts_stop_on_exception = 0; /* --------------------------------------------------------------------------- @@ -844,7 +856,6 @@ eval_obj: debugBelch("\n\n"); ); -// IF_DEBUG(sanity,checkStackChunk(Sp, cap->r.rCurrentTSO->stack+cap->r.rCurrentTSO->stack_size)); IF_DEBUG(sanity,checkStackFrame(Sp)); switch ( get_itbl(obj)->type ) { @@ -1086,11 +1097,33 @@ do_return_pointer: // Returning to an interpreted continuation: put the object on // the stack, and start executing the BCO. INTERP_TICK(it_retto_BCO); - Sp_subW(1); - SpW(0) = (W_)tagged_obj; - obj = (StgClosure*)ReadSpW(2); + obj = (StgClosure*)ReadSpW(1); ASSERT(get_itbl(obj)->type == BCO); - goto run_BCO_return_pointer; + + // Heap check + if (doYouWantToGC(cap)) { + Sp_subW(2); + SpW(1) = (W_)tagged_obj; + SpW(0) = (W_)&stg_ret_p_info; + RETURN_TO_SCHEDULER(ThreadInterpret, HeapOverflow); + } + else { + + // Stack checks aren't necessary at return points, the stack use + // is aggregated into the enclosing function entry point. + + // Make sure stack is headed by a ctoi R1p frame when returning a pointer + ASSERT(ReadSpW(0) == (W_)&stg_ctoi_R1p_info); + + // Add the return frame on top of the args + Sp_subW(2); + SpW(1) = (W_)tagged_obj; + SpW(0) = (W_)&stg_ret_p_info; + } + + /* Keep the ret frame and the ctoi frame for run_BCO. + * See Note [Stack layout when entering run_BCO] */ + goto run_BCO; default: do_return_unrecognised: @@ -1159,8 +1192,9 @@ do_return_nonpointer: // get the offset of the header of the next stack frame offset = stack_frame_sizeW((StgClosure *)Sp); + StgClosure* next_frame = (StgClosure*)(SafeSpWP(offset)); - switch (get_itbl((StgClosure*)(SafeSpWP(offset)))->type) { + switch (get_itbl(next_frame)->type) { case RET_BCO: // Returning to an interpreted continuation: pop the return frame @@ -1168,8 +1202,58 @@ do_return_nonpointer: // executing the BCO. INTERP_TICK(it_retto_BCO); obj = (StgClosure*)ReadSpW(offset+1); + ASSERT(get_itbl(obj)->type == BCO); - goto run_BCO_return_nonpointer; + + // Heap check + if (doYouWantToGC(cap)) { + RETURN_TO_SCHEDULER(ThreadInterpret, HeapOverflow); + } + else { + // Stack checks aren't necessary at return points, the stack use + // is aggregated into the enclosing function entry point. + +#if defined(PROFILING) + /* + Restore the current cost centre stack if a tuple is being returned. + + When a "simple" unlifted value is returned, the cccs is restored with + an stg_restore_cccs frame on the stack, for example: + + ... + stg_ctoi_D1 + <CCCS> + stg_restore_cccs + + But stg_restore_cccs cannot deal with tuples, which may have more + things on the stack. Therefore we store the CCCS inside the + stg_ctoi_t frame. + + If we have a tuple being returned, the stack looks like this: + + ... + <CCCS> <- to restore, Sp offset <next frame + 4 words> + tuple_BCO + tuple_info + cont_BCO + stg_ctoi_t <- next frame + tuple_data_1 + ... + tuple_data_n + tuple_info + tuple_BCO + stg_ret_t <- Sp + */ + + if(SpW(0) == (W_)&stg_ret_t_info) { + cap->r.rCCCS = (CostCentreStack*)ReadSpW(offset + 4); + } +#endif + + /* Keep the ret frame and the ctoi frame for run_BCO. + * See Note [Stack layout when entering run_BCO] */ + goto run_BCO; + } default: { @@ -1332,111 +1416,90 @@ do_apply: RETURN_TO_SCHEDULER_NO_PAUSE(ThreadRunGHC, ThreadYielding); } - // ------------------------------------------------------------------------ - // Ok, we now have a bco (obj), and its arguments are all on the - // stack. We can start executing the byte codes. - // - // The stack is in one of two states. First, if this BCO is a - // function: - // - // | .... | - // +---------------+ - // | arg2 | - // +---------------+ - // | arg1 | - // +---------------+ - // - // Second, if this BCO is a continuation: - // - // | .... | - // +---------------+ - // | fv2 | - // +---------------+ - // | fv1 | - // +---------------+ - // | BCO | - // +---------------+ - // | stg_ctoi_ret_ | - // +---------------+ - // | retval | - // +---------------+ - // - // where retval is the value being returned to this continuation. - // In the event of a stack check, heap check, or context switch, - // we need to leave the stack in a sane state so the garbage - // collector can find all the pointers. - // - // (1) BCO is a function: the BCO's bitmap describes the - // pointerhood of the arguments. - // - // (2) BCO is a continuation: BCO's bitmap describes the - // pointerhood of the free variables. - // - // Sadly we have three different kinds of stack/heap/cswitch check - // to do: - - -run_BCO_return_pointer: - // Heap check - if (doYouWantToGC(cap)) { - Sp_subW(1); SpW(0) = (W_)&stg_ret_p_info; - RETURN_TO_SCHEDULER(ThreadInterpret, HeapOverflow); - } - // Stack checks aren't necessary at return points, the stack use - // is aggregated into the enclosing function entry point. - - goto run_BCO; - -run_BCO_return_nonpointer: - // Heap check - if (doYouWantToGC(cap)) { - RETURN_TO_SCHEDULER(ThreadInterpret, HeapOverflow); - } - // Stack checks aren't necessary at return points, the stack use - // is aggregated into the enclosing function entry point. - -#if defined(PROFILING) - /* - Restore the current cost centre stack if a tuple is being returned. - - When a "simple" unlifted value is returned, the cccs is restored with - an stg_restore_cccs frame on the stack, for example: - - ... - stg_ctoi_D1 - <CCCS> - stg_restore_cccs - - But stg_restore_cccs cannot deal with tuples, which may have more - things on the stack. Therefore we store the CCCS inside the - stg_ctoi_t frame. - - If we have a tuple being returned, the stack looks like this: - - ... - <CCCS> <- to restore, Sp offset <next frame + 4 words> - tuple_BCO - tuple_info - cont_BCO - stg_ctoi_t <- next frame - tuple_data_1 - ... - tuple_data_n - tuple_info - tuple_BCO - stg_ret_t <- Sp - */ - - if(SpW(0) == (W_)&stg_ret_t_info) { - cap->r.rCCCS = (CostCentreStack*)ReadSpW(stack_frame_sizeW((StgClosure *)Sp) + 4); - } -#endif - - if (SpW(0) != (W_)&stg_ret_t_info) { - Sp_addW(1); - } - goto run_BCO; +/* +Note [Stack layout when entering run_BCO] +----------------------------------------- +We have a bco (obj), and its arguments are all on the stack. We can start +executing the byte codes. + +The stack is in one of two states. First, if this BCO is a +function (in run_BCO_fun or run_BCO) + + | .... | + +---------------+ + | arg2 | + +---------------+ + | arg1 | + +---------------+ + +Second, if this BCO is a case cont., as per Note [Case continuation BCOs] (only +in run_BCO): + + | .... | + +---------------+ + | fv2 | + +---------------+ + | fv1 | + +---------------+ + | BCO | + +---------------+ + | stg_ctoi_ret_ | + +---------------+ + | retval | + +---------------+ + | stg_ret_..... | + +---------------+ + +where retval is the value being returned to this continuation. +In the event of a stack check, heap check, context switch, +or breakpoint, we need to leave the stack in a sane state so +the garbage collector can find all the pointers. + + (1) BCO is a function: the BCO's bitmap describes the + pointerhood of the arguments. + + (2) BCO is a continuation: BCO's bitmap describes the + pointerhood of the free variables. + +To reconstruct a valid stack state for yielding (such that when we return to +the interpreter we end up in the same place from where we yielded), we need to +differentiate the two cases again: + + (1) For function BCOs, the arguments are directly on top of the stack, so it + suffices to add a `stg_apply_interp_info` frame header using the BCO that is + being applied to these arguments (i.e. the `obj` being run) + + (2) For continuation BCOs, the stack is already consistent -- that's why we + keep the ret and ctoi frame on top of the stack when we start executing it. + + We couldn't reconstruct a valid stack that resumes the case continuation + execution just from the return and free vars values alone because we wouldn't + know what kind of result it was (are we returning a pointer, non pointer int, + a tuple? etc.); especially considering some frames have different sizes, + notably unboxed tuple return frames (see Note [unboxed tuple bytecodes and tuple_BCO]). + + For consistency, the first instructions in a case continuation BCO, right + after a possible BRK_FUN heading it, are two SLIDEs to remove the stg_ret_ + and stg_ctoi_ frame headers, leaving only the return value followed by the + free vars. Theses slides use statically known offsets computed in StgToByteCode.hs. + Following the continuation BCO diagram above, SLIDING would result in: + + | .... | + +---------------+ + | fv2 | + +---------------+ + | fv1 | + +---------------+ + | retval | + +---------------+ +*/ +// Ok, we now have a bco (obj), and its arguments are all on the stack as +// described by Note [Stack layout when entering run_BCO]. +// We can start executing the byte codes. +// +// Sadly we have three different kinds of stack/heap/cswitch check +// to do: run_BCO_fun: IF_DEBUG(sanity, Sp_subW(2); @@ -1466,6 +1529,7 @@ run_BCO_fun: // Now, actually interpret the BCO... (no returning to the // scheduler again until the stack is in an orderly state). + // See also Note [Stack layout when entering run_BCO] run_BCO: INTERP_TICK(it_BCO_entries); { @@ -1519,7 +1583,7 @@ run_BCO: switch (bci & 0xFF) { - /* check for a breakpoint on the beginning of a let binding */ + /* check for a breakpoint on the beginning of a BCO */ case bci_BRK_FUN: { W_ arg1_brk_array, arg2_info_mod_name, arg3_info_mod_id, arg4_info_index; @@ -1572,6 +1636,20 @@ run_BCO: { breakPoints = (StgArrBytes *) BCO_PTR(arg1_brk_array); + W_ stack_head = ReadSpW(0); + + // When the BRK_FUN is at the start of a case continuation BCO, + // the stack contains the frame returning the value at the start. + // See Note [Stack layout when entering run_BCO] + int is_case_cont_BCO = + stack_head == (W_)&stg_ret_t_info + || stack_head == (W_)&stg_ret_v_info + || stack_head == (W_)&stg_ret_p_info + || stack_head == (W_)&stg_ret_n_info + || stack_head == (W_)&stg_ret_f_info + || stack_head == (W_)&stg_ret_d_info + || stack_head == (W_)&stg_ret_l_info; + // stop the current thread if either `stop_next_breakpoint` is // true OR if the ignore count for this particular breakpoint is zero StgInt ignore_count = ((StgInt*)breakPoints->payload)[arg4_info_index]; @@ -1580,36 +1658,96 @@ run_BCO: // decrement and write back ignore count ((StgInt*)breakPoints->payload)[arg4_info_index] = --ignore_count; } - else if (stop_next_breakpoint == true || ignore_count == 0) + else if ( + /* Doing step-in (but don't stop at case continuation BCOs, + * those are only useful when stepping out) */ + (stop_next_breakpoint == true && !is_case_cont_BCO) + /* Or breakpoint is explicitly enabled */ + || ignore_count == 0) { // make sure we don't automatically stop at the // next breakpoint rts_stop_next_breakpoint = 0; cap->r.rCurrentTSO->flags &= ~TSO_STOP_NEXT_BREAKPOINT; - // allocate memory for a new AP_STACK, enough to - // store the top stack frame plus an - // stg_apply_interp_info pointer and a pointer to - // the BCO - size_words = BCO_BITMAP_SIZE(obj) + 2; - new_aps = (StgAP_STACK *) allocate(cap, AP_STACK_sizeW(size_words)); - new_aps->size = size_words; - new_aps->fun = &stg_dummy_ret_closure; - - // fill in the payload of the AP_STACK - new_aps->payload[0] = (StgClosure *)&stg_apply_interp_info; - new_aps->payload[1] = (StgClosure *)obj; - - // copy the contents of the top stack frame into the AP_STACK - for (i = 2; i < size_words; i++) - { - new_aps->payload[i] = (StgClosure *)ReadSpW(i-2); + /* To yield execution we need to come up with a consistent AP_STACK + * to store in the :history data structure. + */ + if (is_case_cont_BCO) { + + // If the BCO is a case cont. then the stack is headed by the + // stg_ret and a stg_ctoi frames which caused this same BCO + // to be run. This stack is already well-formed, so it + // needs only to be copied to the AP_STACK. + // See Note [Stack layout when entering run_BCO] + + // stg_ret_* + int size_returned_frame = + (stack_head == (W_)&stg_ret_t_info) + ? 2 /* ret_t + tuple_BCO */ + + /* Sp(2) is call_info which records the offset to the next frame + * See also Note [unboxed tuple bytecodes and tuple_BCO] */ + ((ReadSpW(2) & 0xFF)) + : 2; /* ret_* + return value */ + + StgPtr cont_frame_head + = (StgPtr)(SpW(size_returned_frame)); + ASSERT(obj == UNTAG_CLOSURE((StgClosure*)ReadSpW(size_returned_frame+1))); + + // stg_ctoi_* + int size_cont_frame_head = + is_ctoi_nontuple_frame(cont_frame_head) + ? 2 // info+bco +#if defined(PROFILING) + : 5; // or info+bco+tuple_info+tuple_BCO+CCS +#else + : 4; // or info+bco+tuple_info+tuple_BCO +#endif + + // Continuation stack is already well formed, + // so just copy it whole to the AP_STACK + size_words = size_returned_frame + + size_cont_frame_head + + BCO_BITMAP_SIZE(obj) /* payload of cont_frame */; + new_aps = (StgAP_STACK *) allocate(cap, AP_STACK_sizeW(size_words)); + new_aps->size = size_words; + new_aps->fun = &stg_dummy_ret_closure; + + // (1) Fill in the payload of the AP_STACK: + for (i = 0; i < size_words; i++) { + new_aps->payload[i] = (StgClosure *)ReadSpW(i); + } + } + else { + + // The BCO is a function, therefore the arguments are + // directly on top of the stack. + // To construct a valid stack chunk simply add an + // stg_apply_interp and the current BCO to the stack. + // See also Note [Stack layout when entering run_BCO] + + // (1) Allocate memory for a new AP_STACK, enough to store + // the top stack frame plus an stg_apply_interp_info pointer + // and a pointer to the BCO + size_words = BCO_BITMAP_SIZE(obj) + 2; + new_aps = (StgAP_STACK *) allocate(cap, AP_STACK_sizeW(size_words)); + new_aps->size = size_words; + new_aps->fun = &stg_dummy_ret_closure; + + // (1.1) the continuation frame + new_aps->payload[0] = (StgClosure *)&stg_apply_interp_info; + new_aps->payload[1] = (StgClosure *)obj; + + // (1.2.1) copy the args/free vars of the top stack frame into the AP_STACK + for (i = 2; i < size_words; i++) { + new_aps->payload[i] = (StgClosure *)ReadSpW(i-2); + } } // No write barrier is needed here as this is a new allocation SET_HDR(new_aps,&stg_AP_STACK_info,cap->r.rCCCS); - // Arrange the stack to call the breakpoint IO action, and + // (2) Arrange the stack to call the breakpoint IO action, and // continue execution of this BCO when the IO action returns. // // ioAction :: Addr# -- the breakpoint info module @@ -1622,12 +1760,27 @@ run_BCO: ioAction = (StgClosure *) deRefStablePtr ( rts_breakpoint_io_action); - Sp_subW(13); - SpW(12) = (W_)obj; - SpW(11) = (W_)&stg_apply_interp_info; + // (2.1) Construct the continuation to which we'll return in + // this thread after the `rts_breakpoint_io_action` returns. + // + // For case cont. BCOs, the continuation to re-run this BCO + // is already first on the stack. For function BCOs we need + // to add an `stg_apply_interp` apply to the current BCO. + // See Note [Stack layout when entering run_BCO] + if (!is_case_cont_BCO) { + Sp_subW(2); // stg_apply_interp_info + StgBCO* + + // (2.1.2) Write the continuation frame (above the stg_ret + // frame if one exists) + SpW(1) = (W_)obj; + SpW(0) = (W_)&stg_apply_interp_info; + } + + // (2.2) The `rts_breakpoint_io_action` call + Sp_subW(11); SpW(10) = (W_)new_aps; - SpW(9) = (W_)False_closure; // True <=> an exception - SpW(8) = (W_)&stg_ap_ppv_info; + SpW(9) = (W_)False_closure; // True <=> an exception + SpW(8) = (W_)&stg_ap_ppv_info; SpW(7) = (W_)arg4_info_index; SpW(6) = (W_)&stg_ap_n_info; SpW(5) = (W_)BCO_LIT(arg3_info_mod_id); ===================================== 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,16 @@ +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 +<--- should break here too +hello3 +hello4 ===================================== 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/-/compare/712acd47702ac847697c4e9acd7ebaf... -- View it on GitLab: https://gitlab.haskell.org/ghc/ghc/-/compare/712acd47702ac847697c4e9acd7ebaf... You're receiving this email because of your account on gitlab.haskell.org.