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

    }

 {-

 genJump :: CmmExpr {-the branch target-} -> NatM InstrBlock

 genJump expr = do

   (target, _format, code) <- getSomeReg expr

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

 --  Unconditional branches

       BCOND {} -> long_bc_jump_size

       B (TBlock _) -> long_b_jump_size

       B (TReg _) -> 1

       BL _ _ -> 1

       J_TBL {} -> 1

   ORI dst src1 _ -> usage (regOp src1, regOp dst)

   XORI dst src1 _ -> usage (regOp src1, regOp dst)

   J_TBL _ _ t -> usage ([t], [])

   B t -> usage (regTarget t, [])

   BCOND _ l r t -> usage (regTarget t ++ regOp l ++ regOp r, [])

   BL t ps -> usage (t : ps, callerSavedRegisters)

   ORI o1 o2 o3 -> ORI (patchOp o1) (patchOp o2) (patchOp o3)

   XORI o1 o2 o3 -> XORI (patchOp o1) (patchOp o2) (patchOp o3)

   J_TBL ids mbLbl t -> J_TBL ids mbLbl (env t)

   B t -> B (patchTarget t)

   BL t ps -> BL (patchReg t) ps

   BCOND c o1 o2 t -> BCOND c (patchOp o1) (patchOp o2) (patchTarget t)

 isJumpishInstr instr = case instr of

   ANN _ i -> isJumpishInstr i

   J_TBL {} -> True

   B {} -> True

   BL {} -> True

   BCOND {} -> True

 canFallthroughTo :: Instr -> BlockId -> Bool

 canFallthroughTo insn bid =

   case insn of

     B (TBlock target) -> bid == target

     BCOND _ _ _ (TBlock target) -> bid == target

     J_TBL targets _ _ -> all isTargetBid targets

 jumpDestsOfInstr :: Instr -> [BlockId]

 jumpDestsOfInstr (ANN _ i) = jumpDestsOfInstr i

 jumpDestsOfInstr (J_TBL ids _mbLbl _r) = catMaybes ids

 jumpDestsOfInstr (B t) = [id | TBlock id <- [t]]

 jumpDestsOfInstr (BCOND _ _ _ t) = [id | TBlock id <- [t]]

 jumpDestsOfInstr _ = []

   case instr of

     ANN d i -> ANN d (patchJumpInstr i patchF)

     J_TBL ids mbLbl r -> J_TBL (map (fmap patchF) ids) mbLbl r

     B (TBlock bid) -> B (TBlock (patchF bid))

     BCOND c o1 o2 (TBlock bid) -> BCOND c o1 o2 (TBlock (patchF bid))

     _ -> panic $ "patchJumpInstr: " ++ instrCon instr

           block' = foldr insert_dealloc [] insns

       insert_dealloc insn r = case insn of

         ANN _ e -> insert_dealloc e r

         _other

           | jumpDestsOfInstr insn /= [] ->

     --

     -- @if(o2 cond o3) op <- 1 else op <- 0@

     CSET Operand Operand Operand Cond

   | -- | A jump instruction with data for switch/jump tables

     J_TBL [Maybe BlockId] (Maybe CLabel) Reg

   | -- | Unconditional jump (no linking)

     LDRU {} -> "LDRU"

     CSET {} -> "CSET"

     J_TBL {} -> "J_TBL"

     B {} -> "B"

     BL {} -> "BL"

     BCOND {} -> "BCOND"

     | otherwise -> op3 (text "\taddi") o1 o2 (OpImm (ImmInt 0))

   ORI o1 o2 o3 -> op3 (text "\tori") o1 o2 o3

   XORI o1 o2 o3 -> op3 (text "\txori") o1 o2 o3

   J_TBL _ _ r -> pprInstr platform (B (TReg r))

   B l | isLabel l -> line $ text "\tjal" <+> pprOp platform x0 <> comma <+> getLabel platform l

   B (TReg r) -> line $ text "\tjalr" <+> pprOp platform x0 <> comma <+> pprReg W64 r <> comma <+> text "0"

     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

 import qualified GHC.Core.Type as Type

 import GHC.Iface.Env       ( newInteractiveBinder )

 import GHC.Tc.Utils.TcType

 import GHC.Tc.Types.Constraint

 import GHC.Tc.Types.Origin

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

                       $ fmap (foldr plusGlobalRdrEnv emptyGlobalRdrEnv)

                       $ forM imports $ \iface_import -> do

                         let ImpUserSpec spec details = tcIfaceImport iface_import

                         pure $ case details of

                           ImpUserAll -> importsFromIface hsc_env iface spec Nothing

                           ImpUserEverythingBut ns -> importsFromIface hsc_env iface spec (Just ns)

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

   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 qualified Data.ByteString as B

 import qualified Data.ByteString.Builder as B

 import qualified Data.ByteString.Lazy as LB

 import Data.Dynamic

 import Data.Typeable (TypeRep)

 import Data.IORef

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

 import Control.Monad

 import Data.ByteString (ByteString)

 import qualified Data.ByteString.Unsafe as B

 import GHC.Exts

 import qualified GHC.Exts.Heap as Heap

   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('T19847b', normal, compile, [''])

 test('T23022', normal, compile, ['-dcore-lint'])

 test('T23023', normal, compile_fail, ['-O -dcore-lint']) # todo: move this test?

 test('ListTuplePunsPpr', normal, ghci_script, ['ListTuplePunsPpr.script'])

 test('ListTuplePunsPprNoAbbrevTuple', [expect_broken(23135), limit_stdout_lines(13)], ghci_script, ['ListTuplePunsPprNoAbbrevTuple.script'])

 test('T24459', normal, ghci_script, ['T24459.script'])