W8                   -> emit_ bci_OP_INDEX_ADDR_08 []

     _                    -> unsupported_width

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

         toW16 x = let r = fromIntegral x :: Word16

                   in if fromIntegral r == x

                     then r

                     else pprPanic "schemeER_wrk: breakpoint tick/info index too large!" (ppr x)

     tick_addr <- lit1 $ BCONPtrFS $ moduleNameFS $ moduleName tick_mod

     info_addr <- lit1 $ BCONPtrFS $ moduleNameFS $ moduleName info_mod

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

 -- 'InternalModBreaks', and is uniquely identified at runtime by an

 -- 'InternalBreakpointId'.

 --

 module GHC.ByteCode.Breakpoints

   ( -- * Internal Mod Breaks

     InternalModBreaks(..), CgBreakInfo(..)

     -- ** Internal breakpoint identifier

   , InternalBreakpointId(..), BreakInfoIndex

     -- * Operations

     -- ** Internal-level operations

     -- ** Source-level information operations

   , getBreakLoc, getBreakVars, getBreakDecls, getBreakCCS

 import Data.Array

 {-

 Note [Breakpoint identifiers]

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

 Before optimization a breakpoint is identified uniquely with a tick module

 we store it alongside the occurrence module (*info module*) in the

 'InternalBreakpointId' datatype. This is the index that we use at runtime to

 identify a breakpoint.

 -}

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

 -- Indexes into the structures in the @'InternalModBreaks'@ produced during ByteCode generation.

 -- See Note [Breakpoint identifiers]

 data InternalBreakpointId = InternalBreakpointId

   , ibi_info_index :: !BreakInfoIndex -- ^ Breakpoint tick index

   }

   deriving (Eq, Ord)

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

 -- * Internal Mod Breaks

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

         -- 'InternalBreakpointId'.

       , imodBreaks_modBreaks :: !ModBreaks

       }

 mkInternalModBreaks :: Module -> IntMap CgBreakInfo -> ModBreaks -> InternalModBreaks

 mkInternalModBreaks mod im mbs =

   assertPpr (mod == modBreaks_module mbs)

     (text "Constructing InternalModBreaks with the ModBreaks of a different module!") $

       InternalModBreaks im mbs

 -- | Information about a breakpoint that we know at code-generation time

 -- In order to be used, this needs to be hydrated relative to the current HscEnv by

 -- 'hydrateCgBreakInfo'. Everything here can be fully forced and that's critical for

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

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

    , cgb_resty   :: !IfaceType

    }

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

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

 getInternalBreak :: InternalBreakpointId -> InternalModBreaks -> CgBreakInfo

 -- | Assert that the module in the 'InternalBreakpointId' and in

 -- 'InternalModBreaks' match.

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

 -- | Get the source span for this breakpoint

 getBreakLoc = getBreakXXX modBreaks_locs

 -- | Get the vars for this breakpoint

 getBreakVars = getBreakXXX modBreaks_vars

 -- | Get the decls for this breakpoint

 getBreakDecls = getBreakXXX modBreaks_decls

 -- | Get the decls for this breakpoint

 getBreakCCS = getBreakXXX modBreaks_ccs

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

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

 -- Instances

     seqCgBreakInfo CgBreakInfo{..} =

         rnf cgb_tyvars `seq`

         rnf cgb_vars `seq`

 instance Outputable InternalBreakpointId where

   ppr InternalBreakpointId{..} =

 instance Outputable CgBreakInfo where

    ppr info = text "CgBreakInfo" <+>

               parens (ppr (cgb_vars info) <+>

    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

 -- Dehydrating CgBreakInfo

           CgBreakInfo

             { cgb_tyvars = map toIfaceTvBndr ty_vars

             , cgb_vars = map (fmap (\(i, offset) -> (toIfaceIdBndr i, offset))) idOffSets

             , cgb_resty = toIfaceType tick_ty

             }

 {- Note [Inlining and hs-boot files]

 -- 'InternalModBreaks' and 'InternalBreakId's. The latter are constructed

 -- during bytecode generation and can be found in 'GHC.ByteCode.Breakpoints'.

 --

 module GHC.HsToCore.Breakpoints

   ( -- * ModBreaks

     mkModBreaks, ModBreaks(..)

   , whereFrom

   , getModBreaks

   , readModBreaks

   , seqHValue

   , evalBreakpointToId

 evalBreakpointToId eval_break =

   let

     mkUnitId u = fsToUnit $ mkFastStringShortByteString u

     toModule u n = mkModule (mkUnitId u) (mkModuleName n)

   in

     InternalBreakpointId

       , ibi_info_index = eb_info_index eval_break

       }

           -- Reason: Setting of flags in libraries/ghci/GHCi/Run.hs:evalOptsSeq

         Just break -> do

           -- Just case: Stopped at a breakpoint, extract SrcSpan information

           -- from the breakpoint.

           case mb_modbreaks of

             -- Nothing case - should not occur! We should have the appropriate

             -- breakpoint information

             Nothing -> nothing_case

       -- resume the seq (:force) processing in the iserv process

       withForeignRef resume_ctxt_fhv $ \hval -> do

   | otherwise

   = Nothing -- probably object code

 readModBreaks :: HomeUnitGraph -> Module -> IO InternalModBreaks

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

 -- Misc utils

 import GHC.Platform

 import GHC.Platform.Profile

 import GHCi.FFI

 import GHC.Types.Basic

 import GHC.Utils.Outputable

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

 import GHC.Unit.Module

 import Data.Coerce (coerce)

 #if MIN_VERSION_rts(1,0,3)

 -- | Introduce break instructions for ticked expressions.

 -- If no breakpoint information is available, the instruction is omitted.

 schemeER_wrk :: StackDepth -> BCEnv -> CgStgExpr -> BcM BCInstrList

   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

 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

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

 type BreakpointCallback

     -> Addr#   -- pointer to the breakpoint info module unit id

     -> Int#    -- breakpoint info index

     -> Bool    -- exception?

 instance Binary a => Binary (EvalStatus_ a b)

 data EvalBreakpoint = EvalBreakpoint

   , eb_info_mod_unit :: BS.ShortByteString -- ^ Breakpoint tick module unit id

   , eb_info_index    :: Int    -- ^ Breakpoint info index

   }

         -- as soon as it is hit, or in resetBreakAction below.

    onBreak :: BreakpointCallback

      tid <- myThreadId

      let resume = ResumeContext

            { resumeBreakMVar = breakMVar

        if is_exception

        then pure Nothing

        else do

          info_mod <- peekCString (Ptr info_mod#)

          info_mod_uid <- BS.packCString (Ptr info_mod_uid#)

      putMVar statusMVar $ EvalBreak apStack_r breakpoint resume_r ccs

      takeMVar breakMVar

 noBreakStablePtr = unsafePerformIO $ newStablePtr noBreakAction

 noBreakAction :: BreakpointCallback

 -- Malloc and copy the bytes.  We don't have any way to monitor the

 -- lifetime of this memory, so it just leaks.

    switch (instr & 0xff) {

          if (cc) {

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

          }

          debugBelch("\n");

       case bci_BRK_ALTS:

          debugBelch ("BRK_ALTS %d\n", BCO_NEXT);

          break;

             // be per-thread.

             CInt[rts_stop_on_exception] = 0;

             ("ptr" ioAction) = ccall deRefStablePtr (W_[rts_breakpoint_io_action] "ptr");

             R1 = ioAction;

             jump RET_LBL(stg_ap_n) [R1];

         }

         /* 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;

             int size_words;

             arg1_brk_array      = BCO_GET_LARGE_ARG;

 #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

                // stop the current thread if either `stop_next_breakpoint` is

                // true OR if the ignore count for this particular breakpoint is zero

                if (stop_next_breakpoint == false && ignore_count > 0)

                {

                   // decrement and write back ignore count

                }

                else if (stop_next_breakpoint == true || ignore_count == 0)

                {

                   // Arrange the stack to call the breakpoint IO action, and

                   // continue execution of this BCO when the IO action returns.

                   //

                   //          -> Addr#       -- the breakpoint info module unit id

                   //          -> Int#        -- the breakpoint info index

                   //          -> Bool        -- exception?

                   ioAction = (StgClosure *) deRefStablePtr (

                       rts_breakpoint_io_action);

                   SpW(6)  = (W_)&stg_ap_n_info;

                   SpW(4)  = (W_)&stg_ap_n_info;

                   SpW(2)  = (W_)&stg_ap_n_info;

                   SpW(1)  = (W_)ioAction;

                   SpW(0)  = (W_)&stg_enter_info;