{ cgb_tyvars  :: ![IfaceTvBndr] -- ^ Type variables in scope at the breakpoint

    , cgb_vars    :: ![Maybe (IfaceIdBndr, Word)]

    , cgb_resty   :: !IfaceType

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

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

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

   assert_modules_match ibi_mod (imodBreaks_module imbs) $

     let cgb = imodBreaks_breakInfo imbs IM.! ibi_ix

      in case cgb_tick_id cgb of

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

     case cgb_tick_id cgb of

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

                               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

       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

          -- continuation BCO, for step-out.

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

          -> do

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

           mibi <- newBreakInfo breakInfo

           return $ case mibi of

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

 -- Dehydrating CgBreakInfo

 dehydrateCgBreakInfo ty_vars idOffSets tick_ty bid =

           CgBreakInfo

             { cgb_tyvars = map toIfaceTvBndr ty_vars