import qualified Data.List as List ( any )

 import GHC.Exts

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

 -- Unlinked BCOs

   -> FlatBag (ProtoBCO Name)

   -> [TyCon]

   -> [(Name, ByteString)]

   -> [SptEntry]

   -> IO CompiledByteCode

 assembleBCOs profile proto_bcos tycons top_strs modbreaks spt_entries = do

   -- TODO: the profile should be bundled with the interpreter: the rts ways are

   -- fixed for an interpreter

   let itbls = mkITbls profile tycons

   return CompiledByteCode

     { bc_bcos = bcos

     , bc_itbls = itbls

     InternalModBreaks(..), CgBreakInfo(..)

   , mkInternalModBreaks

     -- ** Internal breakpoint identifier

   , InternalBreakpointId(..), BreakInfoIndex

     -- * Utils

   , seqInternalModBreaks

   where

 import GHC.Prelude

 import Control.DeepSeq

 import Data.IntMap.Strict (IntMap)

 import qualified Data.IntMap.Strict as IM

 import GHC.Iface.Syntax

 import GHC.Unit.Module (Module)

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

 {-

 Note [ModBreaks vs InternalModBreaks]

       , imodBreaks_module    :: !Module

         -- ^ Also cache the module corresponding to these 'InternalModBreaks',

         -- for instance for internal sanity checks.

       }

 -- | Construct an 'InternalModBreaks'

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

     (text "Tried to query the InternalModBreaks of module" <+> ppr imbs_mod

         <+> text "with an InternalBreakpointId for module" <+> ppr ibi_mod)

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

 -- Instances

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

 import Data.ByteString (ByteString)

 import qualified GHC.Exts.Heap as Heap

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

 import GHC.Unit.Module

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

   , bc_strs   :: [(Name, ByteString)]

     -- ^ top-level strings (heap allocated)

     --

     -- This information is used when loading a bytecode object: we will

     -- construct the arrays to be used at runtime to trigger breakpoints then

     -- breakpoint information indexed by the internal breakpoint id here (in

     -- 'getModBreaks').

   , bc_spt_entries :: ![SptEntry]

     -- ^ Static pointer table entries which should be loaded along with the

     -- BCOs. See Note [Grand plan for static forms] in

   ( -- * ModBreaks

     mkModBreaks, ModBreaks(..)

     -- ** Re-exports BreakpointId

   , BreakpointId(..), BreakTickIndex

   ) where

 import GHC.Types.Tickish (BreakTickIndex, BreakpointId(..))

 import GHC.Unit.Module (Module)

 import GHC.Utils.Outputable

 import Data.List (intersperse)

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

       , modBreaks_module = modl

       }

 {-

 Note [Field modBreaks_decls]

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

 import GHC.IfaceToCore

 import GHC.HsToCore.Breakpoints

 import Control.Monad

 import Data.Array

 getHistorySpan hug hist = do

   let bid = historyBreakpointId hist

   (_, brks) <- readModBreaks hug (bi_tick_mod bid)

 {- | Finds the enclosing top level function name -}

 -- ToDo: a better way to do this would be to keep hold of the decl_path computed

       (_, tick_brks) <- liftIO $ readModBreaks hug (bi_tick_mod bid)

       breakArray     <- getBreakArray interp ibi

       let

         decl      = intercalate "." $ modBreaks_decls tick_brks ! bi_tick_index bid

       -- Was this breakpoint explicitly enabled (ie. in @BreakArray@)?

                 -- When the user specified a break ignore count, set it

                 -- in the interpreter

                 case (mb_brkpt, mbCnt) of

                     setupBreakpoint interp ibi cnt

                   _ -> return ()

 getBreakArray interp InternalBreakpointId{ibi_info_mod} = do

   breakArrays <- liftIO $ breakarray_env . linker_env . expectJust

                        <$> Loader.getLoaderState interp

   return $ expectJust $ lookupModuleEnv breakArrays ibi_info_mod

 back :: GhcMonad m => Int -> m ([Name], Int, SrcSpan)

                       Nothing  -> return $ mkGeneralSrcSpan (fsLit "<unknown>")

                       Just (bid, _ibi) -> liftIO $ do

                         (_, brks) <- readModBreaks (hsc_HUG hsc_env) (bi_tick_mod bid)

             (hsc_env1, names) <-

               liftIO $ bindLocalsAtBreakpoint hsc_env apStack span (snd <$> mb_info)

             let ic = hsc_IC hsc_env1

   , whereFrom

   , getModBreaks

   , readModBreaks

   , seqHValue

   , evalBreakpointToId

   -- * The object-code linker

   , initObjLinker

 import GHCi.RemoteTypes

 import GHCi.ResolvedBCO

 import GHCi.BreakArray (BreakArray)

 import GHC.ByteCode.Breakpoints

 import GHC.ByteCode.Types

 import GHC.Unit.Module

 import GHC.Unit.Home.ModInfo

 import GHC.Unit.Env

 #if defined(HAVE_INTERNAL_INTERPRETER)

 import GHCi.Run

 #endif

 import Control.Concurrent

 import Control.Monad.Catch as MC (mask)

 import Data.Binary

 import Data.ByteString (ByteString)

 import Foreign hiding (void)

 import qualified GHC.Exts.Heap as Heap

 import System.Directory

 import System.Process

 import qualified GHC.InfoProv as InfoProv

 -- Standard libraries

 import GHC.Exts

 {- Note [Remote GHCi]

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

       , ibi_info_index = eb_info_index eval_break

       }

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

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

 handleSeqHValueStatus interp unit_env eval_status =

         Just break -> do

           let ibi = evalBreakpointToId break

               hug = ue_home_unit_graph unit_env

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

 -- | Get the breakpoint information from the ByteCode object associated to this

 -- 'HomeModInfo'.

 getModBreaks hmi

   | Just linkable <- homeModInfoByteCode hmi,

     -- The linkable may have 'DotO's as well; only consider BCOs. See #20570.

     [cbc] <- linkableBCOs linkable

   | otherwise

   = Nothing -- probably object code

 -- | Read the 'InternalModBreaks' and 'ModBreaks' of the given home 'Module'

 -- from the 'HomeUnitGraph'.

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

 -- Misc utils

 import GHCi.Message         ( Pipe )

 import GHC.Platform

 import GHC.Utils.TmpFs

 import GHC.Utils.Logger

 import GHC.Unit.Env

             flattenBind (StgRec bs)     = bs

         (proto_bcos, BcM_State{..}) <-

              let flattened_binds = concatMap flattenBind (reverse lifted_binds)

              FlatBag.fromList (fromIntegral $ length flattened_binds) <$> mapM schemeTopBind flattened_binds

            "Proto-BCOs" FormatByteCode

            (vcat (intersperse (char ' ') (map ppr $ elemsFlatBag proto_bcos)))

         -- Squash space leaks in the CompiledByteCode.  This is really

         -- important, because when loading a set of modules into GHCi

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

 schemeER_wrk d p (StgTick (Breakpoint tick_ty tick_id fvs) rhs) = do

   code <- schemeE d 0 p rhs

 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

   deriving (Functor, Applicative, Monad, MonadIO)

     via (ReaderT BcM_Env (StateT BcM_State IO))

 instance HasDynFlags BcM where

     getDynFlags = hsc_dflags <$> getHscEnv

 import Data.Data

 import GHC.Utils.Outputable (Outputable (ppr), text, (<+>))

 {- *********************************************************************

 *                                                                      *

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

 -- | Breakpoint tick index

 type BreakTickIndex = Int

 -- | Breakpoint identifier.

 import GHC ( LoadHowMuch(..), Target(..),  TargetId(..),

              Resume, SingleStep, Ghc,

              GetDocsFailure(..), pushLogHookM,

 import GHC.Driver.Main (hscParseModuleWithLocation, hscParseStmtWithLocation)

 import GHC.Hs.ImpExp

 import GHC.Hs

 import GHC.Types.SafeHaskell ( getSafeMode )

 import GHC.Types.SourceError ( SourceError )

 import GHC.Types.Name

 import GHC.Types.Var ( varType )

 import GHC.Iface.Syntax ( showToHeader )

 import GHC.Builtin.Names

           Right names -> do

             show_types <- isOptionSet ShowType

             when show_types $ printTypeOfNames names

          | first_resume : _ <- resumes

                let bCmd = maybe "" ( \(_,l) -> onBreakCmd l ) mb_id_loc

                if (null bCmd)

                  then printStoppedAtBreakInfo first_resume names

     _ -> Nothing

 toBreakIdAndLocation :: GhciMonad m

 toBreakIdAndLocation Nothing = return Nothing

 toBreakIdAndLocation (Just inf) = do

   st <- getGHCiState

   return $ listToMaybe [ id_loc | id_loc@(_,loc) <- IntMap.assocs (breaks st),

 printStoppedAtBreakInfo :: GHC.GhcMonad m => Resume -> [Name] -> m ()

 printStoppedAtBreakInfo res names = do

          <> text (GHC.resumeDecl res))

     <> char ',' <+> ppr (GHC.resumeSpan res)

  where

 showUnits :: GHC.GhcMonad m => m ()

 showUnits = mapNonInteractiveHomeUnitsM $ \dflags -> do

     case result of

       Left sdoc -> printForUser sdoc

       Right (loc, count)   -> do

                   }

 ignoreSwitch :: GhciMonad m => [String] -> m (Either SDoc (BreakLocation, Int))

 ignoreSwitch [break, count] = do

     where

       sdocIgnore = text "Ignore count" <+> quotes (text str)

 setupBreakpoint loc count = do

     hsc_env <- GHC.getSession

 backCmd :: GhciMonad m => String -> m ()

 backCmd arg

     Left sdoc -> printForUser sdoc

     Right (mod, mod_info, fun_str) -> do

       let modBreaks = expectJust (GHC.modInfoModBreaks mod_info)

 breakSyntax :: a

 breakSyntax = throwGhcException $ CmdLineError ("Syntax: :break [<mod>.]<func>[.<func>]\n"

       return loc { breakEnabled = onOff }

 setBreakFlag :: GhciMonad m => Module -> Int -> Bool ->m ()

   let enaDisaToCount True = breakOn

       enaDisaToCount False = breakOff

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

 -- User code exception handling

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

             arg1_brk_array      = BCO_GET_LARGE_ARG;

             arg2_info_mod_name  = BCO_GET_LARGE_ARG;

             arg3_info_mod_id    = BCO_GET_LARGE_ARG;

 #if defined(PROFILING)

             arg5_cc             = BCO_GET_LARGE_ARG;

 #else

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

                {

                   SpW(10) = (W_)new_aps;

                   SpW(9) = (W_)False_closure;         // True <=> an exception

                   SpW(8) = (W_)&stg_ap_ppv_info;

                   SpW(6)  = (W_)&stg_ap_n_info;

                   SpW(5)  = (W_)BCO_LIT(arg3_info_mod_id);

                   SpW(4)  = (W_)&stg_ap_n_info;