CCALL off m_addr i       -> do np <- addr m_addr

                                  emit_ bci_CCALL [wOp off, Op np, SmallOp i]

   PRIMCALL                 -> emit_ bci_PRIMCALL []

                               do p1 <- ptr (BCOPtrBreakArray arr)

                                  tick_addr <- addr tick_mod

                                  info_addr <- addr info_mod

                                  np <- addr cc

                                  emit_ bci_BRK_FUN [ Op p1

                                                   , Op tick_addr, Op info_addr

                                                   , SmallOp tickx, SmallOp infox

                                                   , Op np

                                                   ]

 import GHCi.BreakArray (BreakArray)

 import Language.Haskell.Syntax.Module.Name (ModuleName)

 import GHC.Types.Unique

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

 -- Bytecode instructions

    -- Breakpoints

    | BRK_FUN          (ForeignRef BreakArray)

                       (RemotePtr ModuleName) -- breakpoint tick module

                       !Word16                -- breakpoint tick index

                       (RemotePtr ModuleName) -- breakpoint info module

                       !Word16                -- breakpoint info index

                       (RemotePtr CostCentre)

    ppr ENTER                 = text "ENTER"

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

    ppr (RETURN_TUPLE)        = text "RETURN_TUPLE"

                              = text "BRK_FUN" <+> text "<breakarray>"

                                <+> text "<cc>"

 #if MIN_VERSION_rts(1,0,3)

    ppr (BCO_NAME nm)         = text "BCO_NAME" <+> text (show nm)

 import GHC.Cmm.Expr ( GlobalRegSet, emptyRegSet, regSetToList )

 import GHC.Iface.Syntax

 import Language.Haskell.Syntax.Module.Name (ModuleName)

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

 -- Compiled Byte Code

    , modBreaks_breakInfo :: IntMap CgBreakInfo

         -- ^ info about each breakpoint from the bytecode generator

    , modBreaks_module :: RemotePtr ModuleName

    }

 seqModBreaks :: ModBreaks -> ()

   rnf modBreaks_decls `seq`

   rnf modBreaks_ccs `seq`

   rnf (fmap seqCgBreakInfo modBreaks_breakInfo) `seq`

 -- | Construct an empty ModBreaks

 emptyModBreaks :: ModBreaks

    , modBreaks_ccs = array (0,-1) []

    , modBreaks_breakInfo = IntMap.empty

    , modBreaks_module = toRemotePtr nullPtr

    }

 {-

 import GHC.Cmm.Type ( Width(..) )

 import GHC.Data.FastString

 import GHC.Utils.Outputable

 import GHC.Utils.Misc

 generate calls in derived instances of Enum.  So we compromise: a

 rewrite rule rewrites a bad instance of tagToEnum# to an error call,

 and emits a warning.

 -}

 tagToEnumRule :: RuleM CoreExpr

     Just (tycon, tc_args) | isEnumerationTyCon tycon -> do

       let tag = fromInteger i

           correct_tag dc = (dataConTagZ dc) == tag

     -- See Note [tagToEnum#]

     _ -> warnPprTrace True "tagToEnum# on non-enumeration type" (ppr ty) $

                                  hostFullWays

         in dflags_c

 -- | Populate the Downsweep cache with the root modules.

 mkRootMap

   :: [ModuleNodeInfo]

      , spt <- bc_spt_entries bco

      ]

 -- Note [When source is considered modified]

 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

     breakArray <- GHCi.newBreakArray interp count

     ccs <- mkCCSArray interp mod count entries

     let

            locsTicks  = listArray (0,count-1) [ tick_loc  t | t <- entries ]

            varsTicks  = listArray (0,count-1) [ tick_ids  t | t <- entries ]

                        , modBreaks_decls  = declsTicks

                        , modBreaks_ccs    = ccs

                        , modBreaks_module = mod_ptr

                        }

 mkCCSArray

     -- Just case: we stopped at a breakpoint

     EvalBreak apStack_ref (Just eval_break) resume_ctxt ccs -> do

       tick_brks <- liftIO $ readModBreaks hsc_env (ibi_tick_mod ibi)

       let

         span      = modBreaks_locs tick_brks ! ibi_tick_index ibi

   , mkCostCentres

   , costCentreStackInfo

   , newBreakArray

   , storeBreakpoint

   , breakpointStatus

   , getBreakpointVar

 import GHC.Utils.Fingerprint

 import GHC.Unit.Module

 import GHC.Unit.Home.ModInfo

 import GHC.Unit.Env

 #if defined(HAVE_INTERNAL_INTERPRETER)

 import GHC.Builtin.Names

 import GHC.Types.Name

 -- Standard libraries

 import GHC.Exts

   breakArray <- interpCmd interp (NewBreakArray size)

   mkFinalizedHValue interp breakArray

 storeBreakpoint :: Interp -> ForeignRef BreakArray -> Int -> Int -> IO ()

 storeBreakpoint interp ref ix cnt = do                               -- #19157

     status <- interpCmd interp (Seq hval)

     handleSeqHValueStatus interp unit_env status

 -- | Process the result of a Seq or ResumeSeq message.             #2950

 handleSeqHValueStatus :: Interp -> UnitEnv -> EvalStatus () -> IO (EvalResult ())

             mkGeneralSrcSpan (fsLit "<unknown>")

         Just break -> do

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

           -- from the breakpoint.

           breaks_tick <- getModBreaks . expectJust <$>

           put $ brackets . ppr $

             (modBreaks_locs breaks_tick) ! ibi_tick_index bi

     Nothing -> pure code

     Just current_mod_breaks -> break_info hsc_env tick_mod current_mod mb_current_mod_breaks >>= \case

       Nothing -> pure code

         platform <- profilePlatform <$> getProfile

         let idOffSets = getVarOffSets platform d p fvs

             ty_vars   = tyCoVarsOfTypesWellScoped (tick_ty:map idType fvs)

             breakInfo  = dehydrateCgBreakInfo ty_vars (map toWord idOffSets) tick_ty

         let info_mod_ptr = modBreaks_module current_mod_breaks

         infox <- newBreakInfo breakInfo

         let cc | Just interp <- hsc_interp hsc_env

                       in if fromIntegral r == x

                         then r

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

         return $ breakInstr `consOL` code

 schemeER_wrk d p rhs = schemeE d 0 p rhs

   , getMessage, putMessage, getTHMessage, putTHMessage

   , Pipe, mkPipeFromHandles, mkPipeFromContinuations, remoteCall, remoteTHCall, readPipe, writePipe

   , BreakModule

   , LoadedDLL

   ) where

 import System.Exit

 import System.IO

 import System.IO.Error

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

 -- The RPC protocol between GHC and the interactive server

   -- | Allocate a string for a breakpoint module name.

   -- This uses an empty dummy type because @ModuleName@ isn't available here.

   NewBreakModule

 deriving instance Show (Message a)

 instance Binary a => Binary (EvalStatus_ a b)

 data EvalBreakpoint = EvalBreakpoint

   }

   deriving (Generic, Show)

 -- that type isn't available here.

 data BreakModule

 -- | A dummy type that tags pointers returned by 'LoadDLL'.

 data LoadedDLL

       36 -> Msg <$> (Seq <$> get)

       37 -> Msg <$> return RtsRevertCAFs

       38 -> Msg <$> (ResumeSeq <$> get)

       40 -> Msg <$> (LookupSymbolInDLL <$> get <*> get)

       41 -> Msg <$> (WhereFrom <$> get)

       _  -> error $ "Unknown Message code " ++ (show b)

   Seq a                       -> putWord8 36 >> put a

   RtsRevertCAFs               -> putWord8 37

   ResumeSeq a                 -> putWord8 38 >> put a

   LookupSymbolInDLL dll str   -> putWord8 40 >> put dll >> put str

   WhereFrom a                 -> putWord8 41 >> put a

 import GHC.IO hiding ( bracket )

 import System.Mem.Weak  ( deRefWeak )

 import Unsafe.Coerce

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

 -- Implement messages

   MkCostCentres mod ccs -> mkCostCentres mod ccs

   CostCentreStackInfo ptr -> ccsToStrings (fromRemotePtr ptr)

   NewBreakArray sz -> mkRemoteRef =<< newBreakArray sz

   SetupBreakpoint ref ix cnt -> do

     arr <- localRef ref;

     _ <- setupBreakpoint arr ix cnt

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

    onBreak :: BreakpointCallback

      tid <- myThreadId

      let resume = ResumeContext

            { resumeBreakMVar = breakMVar

        then pure Nothing

        else do

          tick_mod <- peekCString (Ptr tick_mod#)

          info_mod <- peekCString (Ptr info_mod#)

      putMVar statusMVar $ EvalBreak apStack_r breakpoint resume_r ccs

      takeMVar breakMVar

 type BreakpointCallback

      = Addr#   -- pointer to the breakpoint tick module name

     -> Int#    -- breakpoint tick index

     -> Addr#   -- pointer to the breakpoint info module name

     -> Int#    -- breakpoint info index

     -> Bool    -- exception?

     -> HValue  -- the AP_STACK, or exception

 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.

   pokeElemOff (ptr :: Ptr CChar) len 0

   return (castRemotePtr (toRemotePtr ptr))

 mkCostCentres :: String -> [(String,String)] -> IO [RemotePtr CostCentre]

 #if defined(PROFILING)

 mkCostCentres mod ccs = do

 newModuleName name =

   castRemotePtr . toRemotePtr <$> newCString name

 getIdValFromApStack :: HValue -> Int -> IO (Maybe HValue)

 getIdValFromApStack apStack (I# stackDepth) = do

    case getApStackVal# apStack stackDepth of

             // be per-thread.

             CInt[rts_stop_on_exception] = 0;

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

             Sp(7)  = 0;

             Sp(6)  = stg_ap_n_info;

             Sp(5)  = 0;

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

             arg1_brk_array      = BCO_GET_LARGE_ARG;

             arg2_tick_mod       = BCO_GET_LARGE_ARG;

             arg3_info_mod       = 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 the

                // "rts_stop_next_breakpoint" flag is true OR if the

                // ignore count for this particular breakpoint is zero

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

                {

                   // decrement and write back ignore count

                }

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

                {

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

                   //

                   // ioAction :: Addr#       -- the breakpoint tick module

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

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

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

                   //          -> Bool        -- exception?

                   //          -> HValue      -- the AP_STACK, or exception

                   ioAction = (StgClosure *) deRefStablePtr (

                       rts_breakpoint_io_action);

                   SpW(8)  = (W_)&stg_ap_n_info;

                   SpW(6)  = (W_)&stg_ap_n_info;

                   SpW(4)  = (W_)&stg_ap_n_info;

                   SpW(3)  = (W_)BCO_LIT(arg2_tick_mod);

                   SpW(2)  = (W_)&stg_ap_n_info;

 test('T25883b', normal, compile_grep_core, [''])

 test('T25883c', normal, compile_grep_core, [''])

 test('T25883d', [extra_files(['T25883d_import.hs'])], multimod_compile_filter, ['T25883d', '-O -ddump-simpl -dno-typeable-binds -dsuppress-all -dsuppress-uniques', r'grep -e "y ="'])