import GHC.Core.InstEnv

 import GHC.Core

 import GHC.Data.Maybe

 import GHC.Types.Id

 import GHC.Types.TyThing

 import GHC.Types.Name.Env

 import GHC.Types.TypeEnv

 import GHC.Types.PkgQual

 import GHC.Unit

 import GHC.ByteCode.Instr

 import GHC.ByteCode.InfoTable

 import GHC.ByteCode.Types

 import GHC.Runtime.Heap.Layout ( fromStgWord, StgWord )

 import GHC.Types.Name

     W8                   -> emit_ bci_OP_INDEX_ADDR_08 []

     _                    -> unsupported_width

     info_addr <- lit1 $ BCONPtrFS $ moduleNameFS $ moduleName info_mod

     info_unitid_addr <- lit1 $ BCONPtrFS $ unitIdFS $ moduleUnitId info_mod

     info_wix <- int infox

     emit_ bci_BRK_FUN [ Op p1, Op info_addr, Op info_unitid_addr

                       , Op info_wix, Op np ]

     literal (LitRubbish {}) = word 0

     litlabel fs = lit1 (BCONPtrLbl fs)

     words ws = lit (fmap BCONPtrWord ws)

     word w = words (OnlyOne w)

     word2 w1 w2 = words (OnlyTwo w1 w2)

 -- See Note [ModBreaks vs InternalModBreaks] and Note [Breakpoint identifiers]

 module GHC.ByteCode.Breakpoints

   ( -- * Internal Mod Breaks

   , mkInternalModBreaks

     -- ** Operations

 -- 'InternalModBreaks' are constructed during bytecode generation and stored in

 -- 'CompiledByteCode' afterwards.

 data InternalModBreaks = InternalModBreaks

         -- ^ Access code-gen time information about a breakpoint, indexed by

         -- 'InternalBreakpointId'.

       }

 -- | Construct an 'InternalModBreaks'

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

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

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

 -- Instances

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

 import GHC.ByteCode.Types

 import GHC.Cmm.Type (Width)

 import GHC.StgToCmm.Layout     ( ArgRep(..) )

 import GHC.Utils.Outputable

 import GHC.Types.Name

 import Data.ByteString (ByteString)

 #endif

 import GHC.Stg.Syntax

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

 -- Bytecode instructions

                    -- Note [unboxed tuple bytecodes and tuple_BCO] in GHC.StgToByteCode

    -- Breakpoints

    -- An internal breakpoint for triggering a break on any case alternative

    -- See Note [Debugger: BRK_ALTS]

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

 import GHC.Builtin.PrimOps

 import GHC.Builtin.PrimOps.Ids

 import GHC.Unit.Types

 import GHC.Data.FastString

 import GHC.Data.SizedSeq

 import GHC.Linker.Types

 import Data.Array.Unboxed

 import Foreign.Ptr

 import GHC.Exts

 {-

   Linking interpretables into something we can run

   BCONPtrFFIInfo (FFIInfo {..}) -> do

     RemotePtr p <- interpCmd interp $ PrepFFI ffiInfoArgs ffiInfoRet

     pure $ fromIntegral p

 lookupStaticPtr :: Interp -> FastString -> IO (Ptr ())

 lookupStaticPtr interp addr_of_label_string = do

   BCOPtrBCO bco

     -> ResolvedBCOPtrBCO <$> linkBCO interp pkgs_loaded le bco_ix bco

 -- | Look up the address of a Haskell symbol in the currently

 -- loaded units.

 import GHC.Utils.Outputable

 import GHC.Builtin.PrimOps

 import GHC.Types.SptEntry

 import GHCi.Message

 import GHCi.RemoteTypes

 import GHCi.FFI

 import qualified GHC.Exts.Heap as Heap

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

 import GHC.HsToCore.Breakpoints (ModBreaks)

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

 -- Compiled Byte Code

     -- ^ top-level strings (heap allocated)

   , bc_breaks :: (Maybe (InternalModBreaks, ModBreaks))

     --

     -- TODO: If ModBreaks is serialized and reconstructed as part of ModDetails

   , bc_spt_entries :: ![SptEntry]

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

   = BCOPtrName   !Name

   | BCOPtrPrimOp !PrimOp

   | BCOPtrBCO    !UnlinkedBCO

 instance NFData BCOPtr where

   rnf (BCOPtrBCO bco) = rnf bco

   | BCONPtrFS    !FastString

   -- | A libffi ffi_cif function prototype.

   | BCONPtrFFIInfo !FFIInfo

 instance NFData BCONPtr where

   rnf x = x `seq` ()

 import Data.Bifunctor

 import qualified GHC.Unit.Home.Graph as HUG

 import GHC.Unit.Home.PackageTable

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

 %*                                                                      *

 import GHC.Rename.Names

 import GHC.Runtime.Context

 import GHC.Runtime.Interpreter

 import GHC.Types.Avail

 import GHC.Types.Name

 import GHC.Types.Name.Ppr

         minf_instances :: [ClsInst],

         minf_iface     :: Maybe ModIface,

         minf_safe      :: SafeHaskellMode,

   }

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

         -- to package modules too.

 modInfoSafe :: ModuleInfo -> SafeHaskellMode

 modInfoSafe = minf_safe

 modInfoModBreaks = minf_modBreaks

 import Data.List (partition)

 import Data.IORef

 import GHC.Iface.Make (mkRecompUsageInfo)

 {-

 ************************************************************************

         ; let modBreaks

                 | Just (_, specs) <- m_tickInfo

                 , breakpointsAllowed dflags

                 | otherwise

                 = Nothing

 -- | Information attached to Breakpoints generated from Ticks

 --

 -- The breakpoint information stored in 'ModBreaks' is generated during

 -- See Note [ModBreaks vs InternalModBreaks] and Note [Breakpoint identifiers]

 module GHC.HsToCore.Breakpoints

   ( -- * ModBreaks

     -- ** Queries

     -- ** Re-exports BreakpointId

   , BreakpointId(..), BreakTickIndex

 import GHC.Unit.Module (Module)

 import GHC.Utils.Outputable

 import GHC.Utils.Panic

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

 -- ModBreaks

 -- and 'modBreaks_decls'.

 data ModBreaks

    = ModBreaks

         -- ^ An array giving the source span of each breakpoint.

         -- ^ An array giving the names of the free variables at each breakpoint.

         -- ^ An array giving the names of the declarations enclosing each breakpoint.

         -- See Note [Field modBreaks_decls]

    , modBreaks_module :: !Module

         -- ^ The module to which this ModBreaks is associated.

    }

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

 -- generator needs to encode this information for each expression, the data is

 -- allocated remotely in GHCi's address space and passed to the codegen as

 -- foreign pointers.

   = let count = fromIntegral $ sizeSS extendedMixEntries

         entries = ssElts extendedMixEntries

         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 ]

      in ModBreaks

       { modBreaks_locs   = locsTicks

       , modBreaks_vars   = varsTicks

       , modBreaks_decls  = declsTicks

       , modBreaks_module = modl

       }

 -- | Get the source span for this breakpoint

 getBreakLoc  :: BreakpointId -> ModBreaks -> SrcSpan

 -- | Get the vars for this breakpoint

 getBreakVars  :: BreakpointId -> ModBreaks -> [OccName]

 -- | Get the decls for this breakpoint

 getBreakDecls :: BreakpointId -> ModBreaks -> [String]

 -- | Assert that the module in the 'BreakpointId' and in 'ModBreaks' match.

 assert_modules_match :: Module -> Module -> a -> a

 or `where` clause of a declaration called "bar", which itself is declared

 in a `let` or `where` clause of the top-level function called "foo".

 -}

 import GHC.Tc.Utils.Monad

 import GHC.Runtime.Interpreter

 import GHCi.RemoteTypes

 import GHC.Iface.Load

 import GHCi.Message (ConInfoTable(..), LoadedDLL)

 import GHC.ByteCode.Asm

 import GHC.ByteCode.Types

 import GHC.SysTools

 import GHC.Types.Basic

 -- Standard libraries

 import Control.Monad

 import Data.ByteString (ByteString)

 import qualified Data.Set as Set

 import Data.Char (isSpace)

 import GHC.Utils.Exception

 import GHC.Unit.Home.Graph (lookupHug, unitEnv_foldWithKey)

 import GHC.Driver.Downsweep

      { closure_env = emptyNameEnv

      , itbl_env    = emptyNameEnv

      , addr_env    = emptyNameEnv

      }

    , pkgs_loaded = init_pkgs

    , bcos_loaded = emptyModuleEnv

           let le  = linker_env pls

           le2_itbl_env <- linkITbls interp (itbl_env le) (concat $ map bc_itbls cbcs)

           le2_addr_env <- foldlM (\env cbc -> allocateTopStrings interp (bc_strs cbc) env) (addr_env le) cbcs

           let le2 = le { itbl_env = le2_itbl_env

           -- Link the necessary packages and linkables

           new_bindings <- linkSomeBCOs interp (pkgs_loaded pls) le2 cbcs

             le1 = linker_env pls

         ie2 <- linkITbls interp (itbl_env le1) (concatMap bc_itbls cbcs)

         ae2 <- foldlM (\env cbc -> allocateTopStrings interp (bc_strs cbc) env) (addr_env le1) cbcs

         names_and_refs <- linkSomeBCOs interp (pkgs_loaded pls) le2 cbcs

   evaluate $ extendNameEnvList prev_env (zipWith mk_entry bndrs ptrs)

   where

     mk_entry nm ptr = (nm, (nm, AddrPtr ptr))

 import GHC.Prelude

 import GHC.Unit                ( UnitId, Module )

 import GHCi.Message            ( LoadedDLL )

 import GHC.Types.Name.Env      ( NameEnv, emptyNameEnv, extendNameEnvList, filterNameEnv )

 import GHC.Types.Name          ( Name )

 import GHC.Types.SptEntry

 import GHC.Utils.Outputable

 import Control.Concurrent.MVar

 import Data.Time               ( UTCTime )

 import GHC.Unit.Module.Env

 import GHC.Types.Unique.DSet

 import Data.Maybe (mapMaybe)

 import Data.List.NonEmpty (NonEmpty, nonEmpty)

 import qualified Data.List.NonEmpty as NE

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

   , addr_env    :: !AddrEnv

       -- ^ Like 'closure_env' and 'itbl_env', but for top-level 'Addr#' literals,

       -- see Note [Generating code for top-level string literal bindings] in GHC.StgToByteCode.

   }

 filterLinkerEnv :: (Name -> Bool) -> LinkerEnv -> LinkerEnv

   { closure_env = filterNameEnv (f . fst) (closure_env le)

   , itbl_env    = filterNameEnv (f . fst) (itbl_env le)

   , addr_env    = filterNameEnv (f . fst) (addr_env le)

 import qualified Data.List.NonEmpty as NE

 import qualified Data.Semigroup as S

 import GHC.Driver.Env

 import GHC.Driver.Monad

 import GHC.Driver.Session.Inspect

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

 makeModuleLineMap m = do

   mi <- getModuleInfo m

   where

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

     mkTickArray ticks

 getModBreak :: GhcMonad m => Module -> m (Maybe ModBreaks)

 getModBreak m = do

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

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

 -- Getting current breakpoint information

 import GHC.ByteCode.Types

 import GHC.Linker.Loader as Loader

 import GHC.Hs

 import GHC.Types.Unique.Supply

 import GHC.Types.Unique.DSet

 import GHC.Types.TyThing

 import GHC.Types.Unique.Map

 import GHC.Types.Avail

 import GHC.Tc.Utils.Monad

 import GHC.IfaceToCore

 import Control.Monad

 import Data.Array

 import Data.List.NonEmpty (NonEmpty)

 import Unsafe.Coerce ( unsafeCoerce )

 import qualified GHC.Unit.Home.Graph as HUG

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

 -- running a statement interactively

 getHistorySpan :: HUG.HomeUnitGraph -> History -> IO SrcSpan

 getHistorySpan hug hist = do

   let bid = historyBreakpointId hist

   return $ modBreaks_locs brks ! bi_tick_index bid

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

 -- for each tick.

 findEnclosingDecls :: HUG.HomeUnitGraph -> BreakpointId -> IO [String]

 findEnclosingDecls hug bid = do

   return $ modBreaks_decls brks ! bi_tick_index bid

 -- | Update fixity environment in the current interactive context.

     --  - or one of the stepping options in @EvalOpts@ caused us to stop at one

     EvalBreak apStack_ref (Just eval_break) resume_ctxt ccs -> do

       let hug = hsc_HUG hsc_env

       let

         span      = modBreaks_locs tick_brks ! bi_tick_index bid

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

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

       apStack_fhv <- liftIO $ mkFinalizedHValue interp apStack_ref

       resume_ctxt_fhv   <- liftIO $ mkFinalizedHValue interp resume_ctxt

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

                 -- in the interpreter

                 case (mb_brkpt, mbCnt) of

                   _ -> return ()

                 let eval_opts = initEvalOpts dflags (enableGhcStepMode step)

                          | otherwise -> pure prevHistoryLst

                 handleRunStatus step expr bindings final_ids status =<< hist'

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

 back n = moveHist (+n)

             span <- case mb_info of

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

                       Just (bid, _ibi) -> liftIO $ do

             (hsc_env1, names) <-

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

             let ic = hsc_IC hsc_env1

 -- of the breakpoint and the free variables of the expression.

 bindLocalsAtBreakpoint hsc_env apStack_fhv span (Just ibi) = do

    let hug = hsc_HUG hsc_env

    bid       <- internalBreakIdToBreakId hug ibi

        interp = hscInterp hsc_env

        occs   = modBreaks_vars tick_brks ! bi_tick_index bid

 import GHC.Runtime.Interpreter

 import GHCi.FFI

 import GHC.Types.Basic

 import GHC.Utils.Outputable

 import GHC.Types.Name

 import Data.Char

 import GHC.Unit.Module

 import Data.Coerce (coerce)

 #if MIN_VERSION_rts(1,0,3)

 import qualified Data.ByteString.Char8 as BS