GitLab

Rodrigo Mesquita pushed to branch wip/romes/exec-break-has-resume at Glasgow Haskell Compiler / GHC

Commits:

e87649c0

by Rodrigo Mesquita at 2026-11-02T15:03:34+00:00

interp: Make resumeExec and ExecBreak use `Resume` directly

Previously, `Resume` contexts were just put directly in the global
interactive environment state, so they were only accessible through it.

However, in the context of multi-threaded debugging, in that many
threads may hit breakpoints, it no longer suffices to have a global
linear list of breakpoints hit. We need a per-breakpoint Resume context
and need to be able to wield it directly rather than going through a
global context.

The driving changes of this commit are:
- Put the Resume data in ExecBreak
- Make resumeExec receive a Resume as an argument

This also simplifies the interpreter in that we no longer necessarily
rely on the global interactive state to resume a thread. We can do it
directly from the ExecBreak.

The interactive context still maintains a stack of resumes, but
`resumeExec` can no longer pop the resume it resumes off of the
breakpoints stack, since it is no longer guaranteed to be resuming the
first in that list. Hence, callers of `resumeExec` must update ic_resume
on their own.

Fixes #28058

5 changed files:

+ changelog.d/ghc-api-exec-break-resume
compiler/GHC/Runtime/Eval.hs
compiler/GHC/Runtime/Eval/Types.hs
ghc/GHCi/UI.hs
ghc/GHCi/UI/Monad.hs

Changes:

changelog.d/ghc-api-exec-break-resume

 +section: ghc-lib
 +synopsis: An ``ExecBreak`` now stores its ``Resume`` and ``resumeExec`` receives it explicitly
 +issues: #28058
 +mrs: !16889
++
 +description: {
 +- ``ExecBreak`` has a new field ``breakResume :: Resume`` with the context needed
 +  to resume the thread stopped at that breakpoint.
 +- ``resumeExec`` takes a specific ``Resume`` to continue as an extra argument,
 +  instead of resuming the most recent breakpoint in ``ic_resume``.
 +- ``resumeExec`` no longer pops the ``Resume`` off ``ic_resume``. Callers that
 +  rely on the ``ic_resume`` stack must now update it themselves, for instance
 +  if if calling ``resumeExec`` on the first ``Resume`` in the context.
 +}

compiler/GHC/Runtime/Eval.hs

@@ -290,7 +290,8 @@ emptyHistory size = nilBL size
  -- breakpoint if we don't care about that breakpoint (e.g. if using :steplocal
  -- or :stepmodule, rather than :step, we only care about certain breakpoints).
  handleRunStatus :: GhcMonad m
 -                => SingleStep -> String
 +                => SingleStep
 +                -> String
                  -> ResumeBindings
                  -> [Id]
                  -> EvalStatus_ [ForeignHValue] [HValueRef]
@@ -343,7 +344,7 @@ handleRunStatus step expr bindings final_ids status history0 = do
          hsc_env2 = pushResume hsc_env1 resume
        setSession hsc_env2
 -      return (ExecBreak break_ids Nothing)
 +      return (ExecBreak break_ids Nothing resume)
      -- EvalBreak (Just ...) case: the interpreter stopped at a breakpoint
      --
@@ -389,7 +390,7 @@ handleRunStatus step expr bindings final_ids status history0 = do
+             }
            hsc_env2 = pushResume hsc_env1 resume
          setSession hsc_env2
 -        return (ExecBreak break_ids (Just ibi))
 +        return (ExecBreak break_ids (Just ibi) resume)
        else do
          -- resume with the same step type
          let eval_opts = initEvalOpts dflags (enableGhcStepMode step)
@@ -404,65 +405,67 @@ handleRunStatus step expr bindings final_ids status history0 = do
    tracing | RunAndLogSteps <- step = True
            | otherwise              = False
 -resumeExec :: GhcMonad m => SingleStep -> Maybe Int
 +-- | Resume a paused thread given its 'Resume' context.
 +--
 +-- The interactive things in scope are restored to the things available at the
 +-- time this paused thread hit the breakpoint.
 +--
 +-- This 'Resume' is not popped off the interactive `ic_resume` breakpoint
 +-- stack, since there's no way to tell which of the breakpoints in the stack is
 +-- the one we're resuming.
 +resumeExec :: GhcMonad m
 +           => SingleStep
 +           -> Maybe Int
 +           -> Resume
             -> m ExecResult
 -resumeExec step mbCnt
 - = do
 -   hsc_env <- getSession
 -   let ic = hsc_IC hsc_env
 -       resume = ic_resume ic
+-
 -   case resume of
 -     [] -> liftIO $
 -           throwGhcExceptionIO (ProgramError "not stopped at a breakpoint")
 -     (r:rs) -> do
 -        -- unbind the temporary locals by restoring the TypeEnv from
 -        -- before the breakpoint, and drop this Resume from the
 -        -- InteractiveContext.
 -        let (resume_tmp_te,resume_gre_cache) = resumeBindings r
 -            ic' = ic { ic_tythings = resume_tmp_te,
 -                       ic_gre_cache = resume_gre_cache,
 -                       ic_resume   = rs }
 -        setSession hsc_env{ hsc_IC = ic' }
+-
 -        -- remove any bindings created since the breakpoint from the
 -        -- linker's environment
 -        let old_names = map getName resume_tmp_te
 -            new_names = [ n | thing <- ic_tythings ic
 -                            , let n = getName thing
 -                            , not (n `elem` old_names) ]
 -            interp    = hscInterp hsc_env
 -            dflags    = hsc_dflags hsc_env
 -        liftIO $ Loader.deleteFromLoadedHomeEnv interp new_names
+-
 -        case r of
 -          Resume { resumeStmt = expr
 -                 , resumeContext = fhv
 -                 , resumeBindings = bindings
 -                 , resumeFinalIds = final_ids
 -                 , resumeApStack = apStack
 -                 , resumeBreakpointId = mb_brkpt
 -                 , resumeSpan = span
 -                 , resumeHistory = hist } ->
 -               do
 -                -- When the user specified a break ignore count, set it
 -                -- in the interpreter
 -                case (mb_brkpt, mbCnt) of
 -                  (Just brkpt, Just cnt) -> setupBreakpoint interp brkpt cnt
 -                  _ -> return ()
+-
 -                let eval_opts = initEvalOpts dflags (enableGhcStepMode step)
 -                status <- liftIO $ GHCi.resumeStmt interp eval_opts fhv
 -                let prevHistoryLst = fromListBL 50 hist
 -                    hug = hsc_HUG hsc_env
 -                    hist' = case mb_brkpt of
 -                       Nothing -> pure prevHistoryLst
 -                       Just bi
 -                         | breakHere False step span -> do
 -                            hist1 <- liftIO (mkHistory hug apStack bi)
 -                            return $ hist1 `consBL` fromListBL 50 hist
 -                         | otherwise -> pure prevHistoryLst
 -                handleRunStatus step expr bindings final_ids status =<< hist'
 +resumeExec step mbCnt r = do
 +  hsc_env <- getSession
 +  let ic = hsc_IC hsc_env
 +  -- unbind the temporary locals by restoring the TypeEnv from
 +  -- before the breakpoint
 +  let (resume_tmp_te,resume_gre_cache) = resumeBindings r
 +      ic' = ic { ic_tythings = resume_tmp_te,
 +                 ic_gre_cache = resume_gre_cache }
 +  setSession hsc_env{ hsc_IC = ic' }
++
 +  -- remove any bindings created since the breakpoint from the
 +  -- linker's environment
 +  let old_names = map getName resume_tmp_te
 +      new_names = [ n | thing <- ic_tythings ic
 +                      , let n = getName thing
 +                      , not (n `elem` old_names) ]
 +      interp    = hscInterp hsc_env
 +      dflags    = hsc_dflags hsc_env
 +  liftIO $ Loader.deleteFromLoadedHomeEnv interp new_names
++
 +  case r of
 +    Resume { resumeStmt = expr
 +           , resumeContext = fhv
 +           , resumeBindings = bindings
 +           , resumeFinalIds = final_ids
 +           , resumeApStack = apStack
 +           , resumeBreakpointId = mb_brkpt
 +           , resumeSpan = span
 +           , resumeHistory = hist } ->
 +         do
 +          -- When the user specified a break ignore count, set it
 +          -- in the interpreter
 +          case (mb_brkpt, mbCnt) of
 +            (Just brkpt, Just cnt) -> setupBreakpoint interp brkpt cnt
 +            _ -> return ()
++
 +          let eval_opts = initEvalOpts dflags (enableGhcStepMode step)
 +          status <- liftIO $ GHCi.resumeStmt interp eval_opts fhv
 +          let prevHistoryLst = fromListBL 50 hist
 +              hug = hsc_HUG hsc_env
 +              hist' = case mb_brkpt of
 +                 Nothing -> pure prevHistoryLst
 +                 Just bi
 +                   | breakHere False step span -> do
 +                      hist1 <- liftIO (mkHistory hug apStack bi)
 +                      return $ hist1 `consBL` fromListBL 50 hist
 +                   | otherwise -> pure prevHistoryLst
 +          handleRunStatus step expr bindings final_ids status =<< hist'
  setupBreakpoint :: GhcMonad m => Interp -> InternalBreakpointId -> Int -> m ()   -- #19157
  setupBreakpoint interp ibi cnt = do

compiler/GHC/Runtime/Eval/Types.hs

@@ -162,6 +162,8 @@ data ExecResult
      | ExecBreak
         { breakNames   :: [Id]
         , breakPointId :: Maybe InternalBreakpointId
 +       , breakResume  :: Resume
 +         -- ^ to resume this thread blocked on this break
+        }
  -- | Essentially a GlobalRdrEnv, but with additional cached values to allow

ghc/GHCi/UI.hs

@@ -1618,7 +1618,7 @@ runStmt input step = do
             m_result <- GhciMonad.runStmt stmt input step
             case m_result of
                 Nothing     -> return Nothing
 -               Just result -> Just <$> afterRunStmt step (RunStmtResult result)
 +               Just result -> Just <$> afterRunStmt (RunStmtResult result)
      -- `x = y` (a declaration) should be treated as `let x = y` (a statement).
      -- The reason is because GHCi wasn't designed to support `x = y`, but then
@@ -1650,7 +1650,7 @@ runStmt input step = do
        _ <- liftIO $ tryIO $ hFlushAll stdin
        m_result <- GhciMonad.runDecls' decls
        forM m_result $ \result -> do
 -        afterRunStmt step (RunDeclsResult result)
 +        afterRunStmt (RunDeclsResult result)
      mk_stmt :: SrcSpan -> HsBind GhcPs -> GhciLStmt GhcPs
      mk_stmt loc bind =
@@ -1671,10 +1671,9 @@ data RunResult
    | RunDeclsResult [TyThing]
  -- | Clean up the GHCi environment after a statement has run
 -afterRunStmt :: GhciMonad m => SingleStep {-^ Type of step we took just before -}
 -             -> RunResult -> m RunResult
 -afterRunStmt step run_result = do
 -  resumes <- GHC.getResumeContext
 +afterRunStmt :: GhciMonad m
 +             => RunResult -> m RunResult
 +afterRunStmt run_result = do
    case run_result of
      RunDeclsResult things -> do
        show_types <- isOptionSet ShowType
@@ -1685,20 +1684,15 @@ afterRunStmt step run_result = do
          Right ids -> do
            show_types <- isOptionSet ShowType
            when show_types $ printTypeOfIds ids
 -    RunStmtResult (GHC.ExecBreak ids mb_info)
 -        | first_resume : _ <- resumes
 -        -> do mb_id_loc <- toBreakIdAndLocation mb_info
 -              let bCmd = maybe "" ( \(_,l) -> onBreakCmd l ) mb_id_loc
 -              if (null bCmd)
 -                then printStoppedAtBreakInfo first_resume ids
 -                else enqueueCommands [bCmd]
 -              -- run the command set with ":set stop <cmd>"
 -              st <- getGHCiState
 -              enqueueCommands [stop st]
 -              return ()
+-
 -        | otherwise -> resume step Nothing >>=
 -                       afterRunStmt step . RunStmtResult >> return ()
 +    RunStmtResult (GHC.ExecBreak ids mb_info resume) -> do
 +      mb_id_loc <- toBreakIdAndLocation mb_info
 +      let bCmd = maybe "" ( \(_,l) -> onBreakCmd l ) mb_id_loc
 +      if (null bCmd)
 +        then printStoppedAtBreakInfo resume ids
 +        else enqueueCommands [bCmd]
 +      -- run the command set with ":set stop <cmd>"
 +      st <- getGHCiState
 +      enqueueCommands [stop st]
    flushInterpBuffers
    withSignalHandlers $ do
@@ -4401,7 +4395,7 @@ doContinue step = doContinue' step Nothing
  doContinue' :: GhciMonad m => SingleStep -> Maybe Int -> m ()
  doContinue' step mbCnt= do
    runResult <- resume step mbCnt
 -  _ <- afterRunStmt step (RunStmtResult runResult)
 +  _ <- afterRunStmt (RunStmtResult runResult)
    return ()
  abandonCmd :: GhciMonad m => String -> m ()

ghc/GHCi/UI/Monad.hs

@@ -38,6 +38,7 @@ import GHCi.UI.Info (ModInfo)
  import qualified GHC
  import GHC.Driver.Monad hiding (liftIO)
  import GHC.Utils.Outputable
 +import GHC.Utils.Panic
  import qualified GHC.Driver.Ppr as Ppr
  import GHC.Types.Name.Occurrence
  import GHC.Driver.Session
@@ -412,7 +413,12 @@ resume step mbIgnoreCnt = do
      withProgName (progname st) $
      withArgs (args st) $
        reflectGHCi x $ do
 -        GHC.resumeExec step mbIgnoreCnt
 +        GHC.getResumeContext >>= \case
 +          [] -> liftIO $
 +                throwGhcExceptionIO (GHC.ProgramError "not stopped at a breakpoint")
 +          (r:rs) -> do
 +            modifySession $ \env -> env{hsc_IC = (hsc_IC env){ ic_resume = rs }}
 +            GHC.resumeExec step mbIgnoreCnt r
  -- --------------------------------------------------------------------------
  -- timing & statistics