minf_instances = fixSafeInstances safe $ instEnvElts $ md_insts details,

            minf_iface     = Nothing,

            minf_safe      = safe,

          }}

 -- | Desugar a typechecked module.

         minf_instances :: [ClsInst],

         minf_iface     :: Maybe ModIface,

         minf_safe      :: SafeHaskellMode,

   }

         -- We don't want HomeModInfo here, because a ModuleInfo applies

         -- to package modules too.

                         minf_instances = error "getModuleInfo: instances for package module unimplemented",

                         minf_iface     = Just iface,

                         minf_safe      = getSafeMode $ mi_trust iface,

                 }))

 availsToGlobalRdrEnv :: HasDebugCallStack => HscEnv -> Module -> [AvailInfo] -> IfGlobalRdrEnv

 modInfoSafe :: ModuleInfo -> SafeHaskellMode

 modInfoSafe = minf_safe

 modInfoModBreaks = minf_modBreaks

 isDictonaryId :: Id -> Bool

   , ItblEnv, ItblPtr(..)

   , AddrEnv, AddrPtr(..)

   , CgBreakInfo(..)

   , CCostCentre

   , FlatBag, sizeFlatBag, fromSmallArray, elemsFlatBag

   ) where

 import Data.Array

 import Data.ByteString (ByteString)

 import Data.IntMap (IntMap)

 import qualified GHC.Exts.Heap as Heap

 import GHC.Stack.CCS

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

 import GHC.Iface.Syntax

 import GHC.Unit.Types (UnitId(..))

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

 -- | All the information about the breakpoints for a module

 data ModBreaks

    = ModBreaks

         -- ^ The array of flags, one per breakpoint,

         -- indicating which breakpoints are enabled.

    , modBreaks_locs :: !(Array BreakIndex SrcSpan)

   rnf modBreaks_module `seq`

   rnf modBreaks_module_unitid

 {-

 Note [Field modBreaks_decls]

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

 import Data.List (intersperse)

 import Data.Array

 -- | Initialize memory for breakpoint data that is shared between the bytecode

 -- generator and the interpreter.

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

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

            declsTicks = listArray (0,count-1) [ tick_path t | t <- entries ]

 mkCCSArray

   :: Interp -> Module -> Int -> [Tick]

     validateBP _ "" (Just _) = pure $ Just $ text "Function name is missing"

     validateBP _ fun_str (Just modl) = do

         isInterpr <- GHC.moduleIsInterpreted modl

         mb_err_msg <- case isInterpr of

         pure mb_err_msg

 -- | The aim of this function is to find the breakpoints for all the RHSs of

 makeModuleLineMap :: GhcMonad m => Module -> m (Maybe TickArray)

 makeModuleLineMap m = do

   mi <- GHC.getModuleInfo m

   where

     mkTickArray :: [(BreakIndex, SrcSpan)] -> TickArray

     mkTickArray ticks

             max_line = foldr max 0 [ GHC.srcSpanEndLine sp | (_, RealSrcSpan sp _) <- ticks ]

             srcSpanLines pan = [ GHC.srcSpanStartLine pan ..  GHC.srcSpanEndLine pan ]

 getModBreak :: GHC.GhcMonad m

 getModBreak m = do

    mod_info      <- fromMaybe (panic "getModBreak") <$> GHC.getModuleInfo m

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

 -- Getting current breakpoint information

 -- | Read the 'ModBreaks' of the given home 'Module' from the 'HomeUnitGraph'.

 readModBreaks :: HscEnv -> Module -> IO ModBreaks

 bindLocalsAtBreakpoint

         :: HscEnv

       resume_ctxt_fhv <- liftIO $ mkFinalizedHValue interp resume_ctxt

       let put x = putStrLn ("*** Ignoring breakpoint " ++ (showSDocUnsafe x))

       case maybe_break of

           -- Nothing case - should not occur!

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

         Just break -> do

           let bi = evalBreakpointToId break

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

           -- from the breakpoint.

                           lookupHugByModule (ibi_tick_mod bi) (ue_home_unit_graph unit_env)

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

       withForeignRef resume_ctxt_fhv $ \hval -> do

 fromEvalResult (EvalException e) = throwIO (fromSerializableException e)

 fromEvalResult (EvalSuccess a) = return a

 getModBreaks hmi

   | Just linkable <- homeModInfoByteCode hmi,

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

     [cbc] <- linkableBCOs linkable

   | otherwise

 -- | Interpreter uses Profiling way

 interpreterProfiled :: Interp -> Bool

 --

 -- If the breakpoint is inlined from another module, look it up in the home

 -- package table.

 break_info ::

   HscEnv ->

   Module ->

   BcM (Maybe ModBreaks)

 break_info hsc_env mod current_mod current_mod_breaks

   | mod == current_mod

   | otherwise

   = ioToBc (lookupHpt (hsc_HPT hsc_env) (moduleName mod)) >>= \case

       Nothing -> pure Nothing

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

 getVarOffSets platform depth env = map getOffSet

     -- Return all possible bids for a given Module

     bidsByModule :: GhciMonad m => [ModuleName] -> Module -> m [String]

     bidsByModule nonquals mod = do

       pure $ case (moduleName mod) `elem` nonquals of

               True  -> bids

               False -> (combineModIdent (showModule mod)) <$> bids

     -- declarations. See Note [Field modBreaks_decls] in GHC.ByteCode.Types

     addNestedDecls :: GhciMonad m => (String, Module) -> m [String]

     addNestedDecls (ident, mod) = do

 completeModule = wrapIdentCompleterMod $ \w -> do

   hsc_env <- GHC.getSession

   case mb_error of

     Left sdoc -> printForUser sdoc

     Right (mod, mod_info, fun_str) -> do

       findBreakAndSet mod $ \_ -> findBreakForBind fun_str modBreaks

 breakSyntax :: a