W8                   -> emit_ bci_OP_INDEX_ADDR_08 []

     _                    -> unsupported_width

     p1 <- ptr $ BCOPtrBreakArray info_mod

     let -- cast that checks that round-tripping through Word16 doesn't change the value

         toW16 x = let r = fromIntegral x :: Word16

     info_unitid_addr <- lit1 $ BCONPtrFS $ unitIdFS     $ moduleUnitId info_mod

     np               <- lit1 $ BCONPtrCostCentre ibi

     emit_ bci_BRK_FUN [ Op p1, Op info_addr, Op info_unitid_addr

   BRK_ALTS active -> emit_ bci_BRK_ALTS [SmallOp (if active then 1 else 0)]

 {-# LANGUAGE RecordWildCards #-}

 -- | Breakpoint information constructed during ByteCode generation.

 --

     -- ** Internal breakpoint identifier

   , InternalBreakpointId(..), BreakInfoIndex

     -- * Operations

     -- ** Source-level information operations

   , getBreakLoc, getBreakVars, getBreakDecls, getBreakCCS

     -- * Utils

   , seqInternalModBreaks

    { 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

      --

      -- The modules of breakpoint occurrence and breakpoint definition are not

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

    }

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

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

 getInternalBreak :: InternalBreakpointId -> InternalModBreaks -> CgBreakInfo

 getInternalBreak (InternalBreakpointId mod ix) imbs =

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

      in cgb_tick_id cgb

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

 --

 -- 'ModBreaks'. When the tick module is different, we need to look up the

 -- 'ModBreaks' in the HUG for that other module.

 --

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

                    -- Note [unboxed tuple bytecodes and tuple_BCO] in GHC.StgToByteCode

    -- Breakpoints

    -- An internal breakpoint for triggering a break on any case alternative

    -- See Note [Debugger: BRK_ALTS]

    ppr ENTER                 = text "ENTER"

    ppr (RETURN pk)           = text "RETURN  " <+> ppr pk

    ppr (RETURN_TUPLE)        = text "RETURN_TUPLE"

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

 import GHC.StgToCmm.Types

 import GHC.Core

 import GHC.Core.TyCon hiding ( pprPromotionQuote )

 import GHC.Core.Coercion.Axiom

 import GHC.Iface.Load

 import GHCi.Message (ConInfoTable(..), LoadedDLL)

 import GHC.ByteCode.Linker

 import GHC.ByteCode.Asm

 import GHC.ByteCode.Types

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

               let ccs = IM.map

                     (\info ->

                     )

                     imodBreaks_breakInfo

               assertPpr (count == length ccs)

       let imod = modBreaks_module $ imodBreaks_modBreaks ibrks

       IntMap.foldrWithKey (\info_ix cgi bmp -> do

           let ibi = InternalBreakpointId imod info_ix

         ) bmp0 (imodBreaks_breakInfo ibrks)

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

         Nothing -> pure Nothing

         Just ibi -> do

           brks <- readIModBreaks hug ibi

       ix ->

           Just <$> getHistoryModule hug (resumeHistory r !! (ix-1))

 getHistoryModule hug hist = do

   let ibi = historyBreakpointId hist

   brks <- readIModBreaks hug ibi

 getHistorySpan :: HUG.HomeUnitGraph -> History -> IO SrcSpan

 getHistorySpan hug hist = do

                               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

 -- | 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 rhs = schemeE d 0 p rhs

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

 schemeE d s p (StgCase scrut _ _ []) = schemeE d s p scrut

 schemeE d s p (StgCase scrut bndr _ alts)

 {-

     :: StackDepth

     -> Sequel

     -> BCEnv

     -> CgStgExpr

     -> Id

     -> [CgStgAlt]

     -> BcM BCInstrList

   = do

      profile <- getProfile

      hsc_env <- getHscEnv

      let alt_final1

            | ubx_tuple_frame    = SLIDE 0 2 `consOL` alt_final0

            | otherwise          = alt_final0

      add_bco_name <- shouldAddBcoName

      let

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

             in return (PUSH_ALTS alt_bco scrut_rep `consOL` scrut_code)

 {-

 Note [Debugger: BRK_ALTS]

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

   let ctr = nextlabel st

    in return (coerce [ctr .. ctr+n-1], st{nextlabel = ctr+n})

 getCurrentModule :: BcM Module

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

 -- Dehydrating CgBreakInfo

 dehydrateCgBreakInfo ty_vars idOffSets tick_ty bid =

           CgBreakInfo

             { cgb_tyvars = map toIfaceTvBndr ty_vars

 import GHC.Runtime.Eval.Utils

 -- The GHC interface

 import GHC.Runtime.Interpreter

 import GHCi.RemoteTypes

 import GHCi.BreakArray( breakOn, breakOff )

   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

       hug <- hsc_HUG <$> GHC.getSession

       brks <- liftIO $ readIModBreaks hug ibi

       return $ Just $ moduleName $

   return $

     text "Stopped in"

       <+> ((case mb_mod_name of

    switch (instr & 0xff) {

       case bci_BRK_FUN: {

          p1           = BCO_GET_LARGE_ARG;

          info_mod     = BCO_GET_LARGE_ARG;

          info_unit_id = BCO_GET_LARGE_ARG;

          info_wix     = BCO_NEXT;

          np           = BCO_GET_LARGE_ARG;

          debugBelch ("BRK_FUN " );  printPtr( ptrs[p1] );

          debugBelch(" %" FMT_Word, literals[info_mod] );

          debugBelch(" %" FMT_Word, literals[info_unit_id] );

          debugBelch(" %" FMT_Word, info_wix );

          CostCentre* cc = (CostCentre*)literals[np];

          if (cc) {

            debugBelch(" %s", cc->label);

             /* info_mod_name = */ BCO_GET_LARGE_ARG;

             /* info_mod_id   = */ BCO_GET_LARGE_ARG;

             arg4_info_index     = BCO_NEXT;

             StgPtr* ptrs = (StgPtr*)(&bco->ptrs->payload[0]);

             StgArrBytes* breakPoints = (StgArrBytes *) BCO_PTR(arg1_brk_array);

         /* check for a breakpoint on the beginning of a let binding */

         case bci_BRK_FUN:

         {

 #if defined(PROFILING)

 #endif

             StgArrBytes *breakPoints;

             int returning_from_break, stop_next_breakpoint;

             arg2_info_mod_name  = BCO_GET_LARGE_ARG;

             arg3_info_mod_id    = BCO_GET_LARGE_ARG;

             arg4_info_index     = BCO_NEXT;

 #if defined(PROFILING)

 #else

             BCO_GET_LARGE_ARG;

 #endif

 #if defined(PROFILING)

             cap->r.rCCCS = pushCostCentre(cap->r.rCCCS,

 #endif

             // if we are returning from a break then skip this section

                   // copy the contents of the top stack frame into the AP_STACK

                   for (i = 2; i < size_words; i++)

                   {

                   }

                   // No write barrier is needed here as this is a new allocation

 # Step out tests

 test('T26042b', [extra_hc_opts('-O -fno-unoptimized-core-for-interpreter'), extra_files(['T26042b.hs'])], ghci_script, ['T26042b.script'])

 test('T26042d', [extra_hc_opts('-O -fno-unoptimized-core-for-interpreter'), extra_files(['T26042d.hs'])], ghci_script, ['T26042d.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