import GHC.Types.SrcLoc

 import GHC.Types.Name.Occurrence

 import Control.DeepSeq

 import Data.IntMap.Strict (IntMap)

 import qualified Data.IntMap.Strict as IM

 getBreakDecls :: (Module -> IO ModBreaks) -> InternalBreakpointId -> InternalModBreaks -> IO [String]

 getBreakDecls = getBreakXXX modBreaks_decls

 getBreakCCS = getBreakXXX modBreaks_ccs

 -- | Internal utility to access a ModBreaks field at a particular breakpoint index

         symbol

           | null unit = ztmp

           | otherwise = zEncodeString unit ++ "_" ++ ztmp

       Nothing -> pprPanic "loadExternalPlugins"

                   (vcat [ text "Symbol not found"

                         , text "  Library path: " <> text path

 import GHC.Prelude

 import Data.Array

 import GHC.HsToCore.Ticks (Tick (..))

 import GHC.Data.SizedSeq

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

 import GHC.Unit.Module (Module)

 import GHC.Utils.Binary

 import GHC.Utils.Outputable

 import Data.List (intersperse)

 import Data.Coerce

    , modBreaks_decls  :: !(Array BreakTickIndex [String])

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

         -- See Note [Field modBreaks_decls]

         -- ^ Array pointing to cost centre info for each breakpoint;

         -- actual 'CostCentre' allocation is done at link-time.

    , modBreaks_module :: !Module

           | interpreterProfiled =

               listArray

                 (0, count - 1)

                   )

                 | t <- entries

                 ]

             ccs <- {- one ccs ptr per tick index -}

               mkCostCentres

                 interp

                 (elems modBreaks_ccs)

             return $ M.fromList $

               zipWith (\el ix -> (BreakpointId modBreaks_module ix, el)) ccs [0..]

 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 GHC.Stack.CCS (CostCentre,CostCentreStack)

 mallocData :: Interp -> ByteString -> IO (RemotePtr ())

 mallocData interp bs = interpCmd interp (MallocData bs)

 -- | Create a set of BCOs that may be mutually recursive.

 createBCOs :: Interp -> [ResolvedBCO] -> IO [HValueRef]

 evalBreakpointToId eval_break =

   let

     mkUnitId u = fsToUnit $ mkFastStringShortByteString u

   in

     InternalBreakpointId

       { ibi_info_mod   = toModule (eb_info_mod_unit eval_break) (eb_info_mod eval_break)

 lookupSymbol interp str = withSymbolCache interp str $

   case interpInstance interp of

 #if defined(HAVE_INTERNAL_INTERPRETER)

 #endif

     ExternalInterp ext -> case ext of

       ExtIServ i -> withIServ i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

       ExtJS {} -> pprPanic "lookupSymbol not supported by the JS interpreter" (ppr str)

       ExtWasm i -> withWasmInterp i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

 lookupSymbolInDLL :: Interp -> RemotePtr LoadedDLL -> InterpSymbol s -> IO (Maybe (Ptr ()))

 lookupSymbolInDLL interp dll str = withSymbolCache interp str $

   case interpInstance interp of

 #if defined(HAVE_INTERNAL_INTERPRETER)

 #endif

     ExternalInterp ext -> case ext of

       ExtIServ i -> withIServ i $ \inst -> fmap fromRemotePtr <$> do

         uninterruptibleMask_ $

       ExtJS {} -> pprPanic "lookupSymbol not supported by the JS interpreter" (ppr str)

       -- wasm dyld doesn't track which symbol comes from which .so

       ExtWasm {} -> lookupSymbol interp str

 lookupClosure :: Interp -> InterpSymbol s -> IO (Maybe HValueRef)

 lookupClosure interp str =

 -- | 'withSymbolCache' tries to find a symbol in the 'interpLookupSymbolCache'

 -- which maps symbols to the address where they are loaded.

   -- These all invoke the corresponding functions in the RTS Linker API.

   InitLinker :: Message ()

   LoadDLLs :: [String] -> Message (Either String [RemotePtr LoadedDLL])

   LoadArchive :: String -> Message () -- error?

   LoadObj :: String -> Message () -- error?

   -- | Create a set of CostCentres with the same module name

   MkCostCentres

    -> Message [RemotePtr CostCentre]

   -- | Show a 'CostCentreStack' as a @[String]@

 instance Binary a => Binary (EvalStatus_ a b)

 data EvalBreakpoint = EvalBreakpoint

   , eb_info_mod_unit :: BS.ShortByteString -- ^ Breakpoint tick module unit id

   , eb_info_index    :: Int    -- ^ Breakpoint info index

   }

 import GHCi.Message (LoadedDLL)

 import Control.Exception (throwIO, ErrorCall(..))

 import Control.Monad    ( when )

 import Data.Foldable

 import Foreign.C

 import Foreign.Marshal.Alloc ( alloca, free )

 purgeObj :: String -> IO ()

 purgeObj f = throwIO $ ErrorCall $ "purgeObj: unsupported on wasm for " <> f

   evaluate $ if r == nullPtr then Nothing else Just r

 lookupSymbolInDLL _ _ = pure Nothing

 resolveObjs :: IO Bool

 initObjLinker RetainCAFs = c_initLinker_ 1

 initObjLinker _ = c_initLinker_ 0

 lookupSymbol str_in = do

    let str = prefixUnderscore str_in

      addr <- c_lookupSymbol c_str

      if addr == nullPtr

         then return Nothing

         else return (Just addr)

 lookupSymbolInDLL dll str_in = do

    let str = prefixUnderscore str_in

      addr <- c_lookupSymbolInNativeObj dll c_str

      if addr == nullPtr

        then return Nothing

        else return (Just addr)

 prefixUnderscore

  | otherwise          = id

 -- | loadDLL loads a dynamic library using the OS's native linker

 #endif

 lookupClosure str = do

   m <- lookupSymbol str

   case m of

 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

 foreign import javascript "((ptr,off) => globalThis.h$lookupClosure(h$decodeUtf8z(ptr,off)))" lookupJSClosure# :: CString -> State# RealWorld -> (# State# RealWorld, Int# #)

   case lookupJSClosure# cstr s of

     (# s', r #) -> (# s', I# r #))

 lookupJSClosure str = lookupJSClosure' str >>= \case

   0 -> pure Nothing

   r -> pure (Just (RemoteRef (RemotePtr (fromIntegral r))))

        if is_exception

        then pure Nothing

        else do

          info_mod_uid <- BS.packCString (Ptr info_mod_uid#)

          pure (Just (EvalBreakpoint info_mod info_mod_uid (I# infox#)))

      putMVar statusMVar $ EvalBreak apStack_r breakpoint resume_r ccs

   pokeElemOff (ptr :: Ptr CChar) len 0

   return (castRemotePtr (toRemotePtr ptr))

 #if defined(PROFILING)

 mkCostCentres mod ccs = do

   mapM (mk_one c_module) ccs

  where

   mk_one c_module (decl_path,srcspan) = do

     toRemotePtr <$> c_mkCostCentre c_name c_module c_srcspan

 foreign import ccall unsafe "mkCostCentre"

   c_mkCostCentre :: Ptr CChar -> Ptr CChar -> Ptr CChar -> IO (Ptr CostCentre)

 #else

 {-# LANGUAGE RecordWildCards #-}

 module Main (main) where

 import Control.Exception

 import Control.Monad

 import Foreign

 rotateSO

   :: (FunPtr (IO (StablePtr a)) -> (IO (StablePtr a)))

   -> (Maybe FilePath, FilePath)

   -> IO a

 rotateSO dynamicCall symName (old, newDLL) = do

 import GHCi.ObjLink

 lookupClosure "blah"

 module Main (main) where

 import Foreign

     }

     return 0;

   }

 }

 // The main entry point of dyld that may be run on node/browser, and