-- necessarily the same: See Note [Breakpoint identifiers].

      --

      -- If there is no original tick identifier (that is, the breakpoint was

    }

 -- See Note [Syncing breakpoint info] in GHC.Runtime.Eval

 -- | Breakpoints created during code generation don't have a source-level tick

 -- | Get an internal breakpoint info by 'InternalBreakpointId'

 getInternalBreak :: InternalBreakpointId -> InternalModBreaks -> CgBreakInfo

 -- | 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 ibi_mod ibi_ix) imbs =

   assert_modules_match ibi_mod (imodBreaks_module imbs) $

     let cgb = imodBreaks_breakInfo imbs IM.! ibi_ix

 -- | 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

 -- | Get the source span for this breakpoint

 getBreakLoc :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO SrcSpan

 -- | Get the vars for this breakpoint

 getBreakVars :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [OccName]

 -- | Get the decls for this breakpoint

 getBreakDecls :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [String]

 -- | Get the decls for this breakpoint

 -- | Internal utility to access a ModBreaks field at a particular breakpoint index

 --

 --

 -- To avoid cyclic dependencies, we instead receive a function that looks up

 -- the 'ModBreaks' given a 'Module'

   assert_modules_match ibi_mod (imodBreaks_module imbs) $ do

     let cgb = imodBreaks_breakInfo imbs IM.! ibi_ix

         | bi_tick_mod == ibi_mod

         -> do

           let these_mbs = imodBreaks_modBreaks imbs

         -> do

           other_mbs <- lookupModule bi_tick_mod

           return $ view other_mbs ! bi_tick_index

 --------------------------------------------------------------------------------

 -- Instances

               let count = maybe 0 ((+1) . fst) $ IM.lookupMax imodBreaks_breakInfo

               let ccs = IM.map

                     (\info ->

                     )

                     imodBreaks_breakInfo

               assertPpr (count == length ccs)

             Right (BreakpointId tick_mod tick_ix)

               -> extendModuleEnvWith (IntMap.unionWith (S.<>)) bmp tick_mod (IntMap.singleton tick_ix [ibi])

             Left _

               -> bmp

         ) bmp0 (imodBreaks_breakInfo ibrks)

                               assertNonVoidIds, assertNonVoidStgArgs )

 import GHC.StgToCmm.Layout

 import GHC.Runtime.Heap.Layout hiding (WordOff, ByteOff, wordsToBytes)

 import GHC.Data.Bitmap

 import GHC.Data.FlatBag as FlatBag

 import GHC.Data.OrdList

 import Control.Monad.IO.Class

 import Control.Monad.Trans.Reader (ReaderT(..))

 import Control.Monad.Trans.State  (StateT(..))

 -- -----------------------------------------------------------------------------

 -- Generating byte code for a complete module

   -- See Note [Debugger: Stepout internal break locs]

   code <- withBreakTick bp $ schemeE d 0 p rhs

       ty_vars   = tyCoVarsOfTypesWellScoped (tick_ty:map idType fvs)

       toWord :: Maybe (Id, WordOff) -> Maybe (Id, Word)

       toWord = fmap (\(i, wo) -> (i, fromIntegral wo))

   mibi <- newBreakInfo breakInfo

 schemeER_wrk d p rhs = schemeE d 0 p rhs

 getVarOffSets :: Platform -> StackDepth -> BCEnv -> [Id] -> [Maybe (Id, WordOff)]

 getVarOffSets platform depth env = map getOffSet

   where

     getOffSet id = case lookupBCEnv_maybe id env of

 fvsToEnv :: BCEnv -> CgStgRhs -> [Id]

 -- Takes the free variables of a right-hand side, and

         -- 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.

         -- The stack space used to save/restore the CCCS when profiling

         save_ccs_size_b | profiling &&

      let

          -- drop the stg_ctoi_*_info header...

          -- after dropping the stg_ret_*_info header

      -- 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.

          -- continuation BCO, for step-out.

          -- See Note [Debugger: Stepout internal break locs]

          -> do

               ty_vars   = tyCoVarsOfTypesWellScoped (tick_ty:map idType fvs)

               toWord :: Maybe (Id, WordOff) -> Maybe (Id, Word)

               toWord = fmap (\(i, wo) -> (i, fromIntegral wo))

           mibi <- newBreakInfo breakInfo

           return $ case mibi of

          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-}

                            p scrut

      if ubx_tuple_frame

        then do let tuple_bco = tupleBCO platform call_info args_offsets

                   _     -> panic "schemeE(StgCase).push_alts"

             in return (PUSH_ALTS alt_bco scrut_rep `consOL` scrut_code)

 {-

 Note [Debugger: Stepout internal break locs]

 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

     - 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)

 getCurrentModule :: BcM Module

 getCurrentModule = BcM $ \env st -> return (bcm_module env, st)

 withBreakTick :: StgTickish -> BcM a -> BcM a

 withBreakTick bp (BcM act) = BcM $ \env st ->

   act env{last_bp_tick=Just bp} st

   brks <- liftIO $ readIModBreaks hug inf

   let bi = getBreakSourceId inf brks

   return $ listToMaybe [ id_loc | id_loc@(_,loc) <- IntMap.assocs (breaks st),

 printStoppedAtBreakInfo :: GHC.GhcMonad m => Resume -> [Name] -> m ()

 printStoppedAtBreakInfo res names = do

 -- stepout of foo True to caller (ie bar)

 :stepout

 :list

 -- stepout of bar (to branch of foo False, where bar was called)

 :stepout

 :list

 -- stepout to right after the call to foo False in main

 :stepout

 :list

 -- done

 :continue

 10  foo True  i = return i

                   ^^^^^^^^

 11  foo False _ = do

 _result ::

   GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld

   -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld,

 20    y <- foo True t

       ^^^^^^^^^^^^^^^

 21    return y

 _result ::

   GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld

   -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld,

 14    n <- bar (x + y)

       ^^^^^^^^^^^^^^^^

 15    return n

 _result ::

   GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld

   -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld,

 5    a <- foo False undefined

      ^^^^^^^^^^^^^^^^^^^^^^^^

 6    print a

 14

 14

 10  foo True  i = return i

                   ^^^^^^^^

 11  foo False _ = do

 _result ::

   GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld

   -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld,

 12    putStrLn "hello2.2"

 hello2.1

 hello2.2

 _result ::

   GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld

   -> (# GHC.Internal.Prim.State# GHC.Internal.Prim.RealWorld,

 11    let !z = y x

       ^^^^^^^^^^^^

 12    let !t = y ['b']

 _result :: IO () = _

 17  main = do

 18    let !(x, y) = a

 :list

 -- out of t

 :stepout

 :list

 -- out of g

 :stepout

 :list

 -- out of f

 :stepout

                   ^^

 22  {-# OPAQUE t #-}

 7248

 Not stopped at a breakpoint; nothing to list

 Not stopped at a breakpoint; nothing to list

 21    pure (x + 3)

                   ^^

 22  {-# OPAQUE t #-}

 _result :: Identity Int = _

 13  g x = do

 14    a <- t (x*2)

       ^^^^^^^^^^^^

 15    n <- pure (a+a)

 _result :: Identity Int = _

 7  f x = do

 8    b <- g (x*x)

      ^^^^^^^^^^^^

 9    y <- pure (b+b)

 7248

 11  succ x = (-) (x - 2) (x + 1)

              ^^^^^^^^^^^^^^^^^^^

 12  

 _result :: Int = _

 5  top = do

    vv